Add Uint64 and Uint128 classes (#1247)

ddoktorski · web-flow · commit 020a0a9a00cd · 2024-01-10T22:29:50.000+01:00
* Add classes for `u64` and `u128` types

* Add regex validation to `Felt` class

* Use serliazation logic to get broadcasted tx v3 common properties

* Add tests for `DAModeField`

* Add `NumberAsHex` class

* Use `NumberAsHex` instead of `Felt` for some fields to align with RPC spec
diff --git a/starknet_py/net/full_node_client.py b/starknet_py/net/full_node_client.py
@@ -68,7 +68,6 @@
     PendingBlockStateUpdateSchema,
     PendingStarknetBlockSchema,
     PendingStarknetBlockWithTxHashesSchema,
-    ResourceBoundsMappingSchema,
     SentTransactionSchema,
     SierraContractClassSchema,
     SimulatedTransactionSchema,
@@ -78,6 +77,7 @@
     TransactionReceiptSchema,
     TransactionStatusResponseSchema,
     TransactionTraceSchema,
+    TransactionV3Schema,
     TypesOfTransactionsSchema,
 )
 from starknet_py.net.schemas.utils import _extract_tx_version
@@ -955,16 +955,7 @@ def _create_broadcasted_txn_common_properties(transaction: AccountTransaction) -
 def _create_broadcasted_txn_v3_common_properties(
     transaction: Union[DeclareV3, InvokeV3, DeployAccountV3]
 ) -> dict:
-    resource_bonds = cast(
-        Dict, ResourceBoundsMappingSchema().dump(obj=transaction.resource_bounds)
+    return cast(
+        Dict,
+        TransactionV3Schema(exclude=["version", "signature"]).dump(obj=transaction),
     )
-
-    broadcasted_txn_v3_common_properties = {
-        "resource_bounds": resource_bonds,
-        "tip": _to_rpc_felt(transaction.tip),
-        "paymaster_data": [_to_rpc_felt(data) for data in transaction.paymaster_data],
-        "nonce_data_availability_mode": transaction.nonce_data_availability_mode.name,
-        "fee_data_availability_mode": transaction.fee_data_availability_mode.name,
-    }
-
-    return broadcasted_txn_v3_common_properties
diff --git a/starknet_py/net/schemas/common.py b/starknet_py/net/schemas/common.py
@@ -1,4 +1,5 @@
 import re
+import sys
 from typing import Any, Mapping, Optional, Union
 
 from marshmallow import Schema, ValidationError, fields, post_load
@@ -25,13 +26,30 @@ def _pascal_to_screaming_upper(checked_string: str) -> str:
     return re.sub(r"(?<!^)(?=[A-Z])", "_", checked_string).upper()
 
 
-class Felt(fields.Field):
+class NumberAsHex(fields.Field):
     """
-    Field that serializes int to felt (hex encoded string)
+    This field performs the following operations:
+
+    - Serializes integers into hexadecimal strings
+    - Deserializes hexadecimal strings into integers
+
+    If a valid hexadecimal string is provided during serialization, it is returned as is.
+    Similarly, when a valid integer is provided during deserialization, it remains unchanged.
     """
 
+    MAX_VALUE = sys.maxsize
+    REGEX_PATTERN = r"^0x[a-fA-F0-9]+$"
+
     def _serialize(self, value: Any, attr: str, obj: Any, **kwargs):
-        return hex(value)
+        if self._is_int_and_in_range(value):
+            return hex(value)
+
+        if self._is_str_and_valid_pattern(value):
+            return value
+
+        raise ValidationError(
+            f"Invalid value provided for {self.__class__.__name__}: {value}"
+        )
 
     def _deserialize(
         self,
@@ -40,16 +58,51 @@ def _deserialize(
         data: Union[Mapping[str, Any], None],
         **kwargs,
     ):
-        if isinstance(value, int):
+        if self._is_int_and_in_range(value):
             return value
 
-        if not isinstance(value, str) or not value.startswith("0x"):
-            raise ValidationError(f"Invalid value provided for felt: {value}.")
-
-        try:
+        if self._is_str_and_valid_pattern(value):
             return int(value, 16)
-        except ValueError as error:
-            raise ValidationError("Invalid felt.") from error
+
+        raise ValidationError(
+            f"Invalid value provided for {self.__class__.__name__}: {value}"
+        )
+
+    def _is_int_and_in_range(self, value: Any) -> bool:
+        return isinstance(value, int) and 0 <= value < self.MAX_VALUE
+
+    def _is_str_and_valid_pattern(self, value: Any) -> bool:
+        return (
+            isinstance(value, str)
+            and re.fullmatch(self.REGEX_PATTERN, value) is not None
+        )
+
+
+class Felt(NumberAsHex):
+    """
+    Field used to serialize and deserialize felt type.
+    """
+
+    MAX_VALUE = 2**252
+    REGEX_PATTERN = r"^0x(0|[a-fA-F1-9]{1}[a-fA-F0-9]{0,62})$"
+
+
+class Uint64(NumberAsHex):
+    """
+    Field used to serialize and deserialize RPC u64 type.
+    """
+
+    MAX_VALUE = 2**64
+    REGEX_PATTERN = r"^0x(0|[a-fA-F1-9]{1}[a-fA-F0-9]{0,15})$"
+
+
+class Uint128(NumberAsHex):
+    """
+    Field used to serialize and deserialize RPC u128 type.
+    """
+
+    MAX_VALUE = 2**128
+    REGEX_PATTERN = r"^0x(0|[a-fA-F1-9]{1}[a-fA-F0-9]{0,31})$"
 
 
 class NonPrefixedHex(fields.Field):
diff --git a/starknet_py/net/schemas/common_test.py b/starknet_py/net/schemas/common_test.py
@@ -1,55 +1,170 @@
+from typing import Optional, Type, Union
+
 import pytest
 from marshmallow import Schema, ValidationError
 
-from starknet_py.net.client_models import BlockStatus, TransactionStatus
-from starknet_py.net.schemas.common import NonPrefixedHex
-from starknet_py.net.schemas.rpc import BlockStatusField, Felt, StatusField
+from starknet_py.net.client_models import BlockStatus, DAMode, Hash, TransactionStatus
+from starknet_py.net.schemas.common import (
+    BlockStatusField,
+    DAModeField,
+    Felt,
+    NonPrefixedHex,
+    StatusField,
+    Uint64,
+    Uint128,
+)
 
 
-def test_serialize_felt():
-    class SchemaWithFelt(Schema):
-        value1 = Felt(data_key="value1")
+class SchemaWithUint64(Schema):
+    value = Uint64(data_key="value")
 
-    data = {"value1": 2137}
 
-    serialized = SchemaWithFelt().dumps(data)
-    assert '"value1": "0x859"' in serialized
+class SchemaWithUint128(Schema):
+    value = Uint128(data_key="value")
+
+
+class SchemaWithFelt(Schema):
+    value = Felt(data_key="value")
 
 
-def test_serialize_felt_throws_on_none():
-    class SchemaWithFelt(Schema):
-        value1 = Felt(data_key="value1")
+class SchemaWithDAModeField(Schema):
+    value = DAModeField(data_key="value")
 
-    data = {"value1": None}
-    with pytest.raises(TypeError):
+
+def test_serialize_felt():
+    data = {"value": 2137}
+
+    serialized = SchemaWithFelt().dumps(data)
+    assert '"value": "0x859"' in serialized
+
+
+@pytest.mark.parametrize(
+    "data",
+    [
+        {"value": None},
+        {"value": 2**252},
+    ],
+)
+def test_serialize_felt_throws_on_invalid_data(data):
+    with pytest.raises(ValidationError, match="Invalid value provided for Felt"):
         SchemaWithFelt().dumps(data)
 
 
 def test_deserialize_felt():
-    class SchemaWithFelt(Schema):
-        value1 = Felt(data_key="value1")
-
-    data = {"value1": "0x859"}
+    data = {"value": "0x859"}
 
     deserialized = SchemaWithFelt().load(data)
     assert isinstance(deserialized, dict)
-    assert deserialized["value1"] == 2137
+    assert deserialized["value"] == 2137
 
 
 def test_deserialize_felt_throws_on_invalid_data():
-    class SchemaWithFelt(Schema):
-        value1 = Felt(data_key="value1")
-
-    data = {"value1": "2137"}
+    data = {"value": "2137"}
 
-    with pytest.raises(ValidationError, match="Invalid value provided for felt"):
+    with pytest.raises(ValidationError, match="Invalid value provided for Felt"):
         SchemaWithFelt().load(data)
 
-    data = {"value1": "0xwww"}
-    with pytest.raises(ValidationError, match="Invalid felt."):
+    data = {"value": "0xwww"}
+    with pytest.raises(ValidationError, match="Invalid value provided for Felt"):
         SchemaWithFelt().load(data)
 
 
+@pytest.mark.parametrize(
+    "data, expected_serialized",
+    (
+        ({"value": 0}, "0x0"),
+        ({"value": "0x100"}, "0x100"),
+        ({"value": 2**32}, "0x100000000"),
+    ),
+)
+def test_serialize_uint64(data, expected_serialized):
+    serialized = SchemaWithUint64().dumps(data)
+    assert f'"value": "{expected_serialized}"' in serialized
+
+
+@pytest.mark.parametrize(
+    "data",
+    [{"value": -1}, {"value": 2**64}, {"value": None}],
+)
+def test_serialize_uint64_throws_on_invalid_data(data):
+    with pytest.raises(
+        ValidationError,
+        match=get_uint_error_message(Uint64, data["value"]),
+    ):
+        SchemaWithUint64().dumps(data)
+
+
+@pytest.mark.parametrize(
+    "data",
+    [{"value": "0x100000000"}, {"value": 2**32}],
+)
+def test_deserialize_uint64(data):
+    deserialized = SchemaWithUint64().load(data)
+    assert isinstance(deserialized, dict)
+    assert deserialized["value"] == 2**32
+
+
+@pytest.mark.parametrize(
+    "data",
+    [
+        {"value": -1},
+        {"value": "1000"},
+        {"value": 2**64},
+        {"value": "0xwrong"},
+        {"value": ""},
+    ],
+)
+def test_deserialize_uint64_throws_on_invalid_data(data):
+    with pytest.raises(
+        ValidationError,
+        match=get_uint_error_message(Uint64, data["value"]),
+    ):
+        SchemaWithUint64().load(data)
+
+
+def test_serialize_uint128():
+    data = {"value": 2**64}
+    serialized = SchemaWithUint128().dumps(data)
+    assert '"value": "0x10000000000000000"' in serialized
+
+
+def test_serialize_uint128_throws_on_invalid_data():
+    data = {"value": 2**128}
+    with pytest.raises(
+        ValidationError,
+        match=get_uint_error_message(Uint128, data["value"]),
+    ):
+        SchemaWithUint128().dumps(data)
+
+
+@pytest.mark.parametrize(
+    "data",
+    [{"value": "0x10000000000000000"}, {"value": 2**64}],
+)
+def test_deserialize_uint128(data):
+    deserialized = SchemaWithUint128().load(data)
+    assert isinstance(deserialized, dict)
+    assert deserialized["value"] == 2**64
+
+
+@pytest.mark.parametrize(
+    "data",
+    [
+        {"value": -1},
+        {"value": "1000"},
+        {"value": 2**128},
+        {"value": "0xwrong"},
+        {"value": ""},
+    ],
+)
+def test_deserialize_uint128_throws_on_invalid_data(data):
+    with pytest.raises(
+        ValidationError,
+        match=get_uint_error_message(Uint128, data["value"]),
+    ):
+        SchemaWithUint128().load(data)
+
+
 def test_serialize_hex():
     class SchemaWithHex(Schema):
         value1 = NonPrefixedHex(data_key="value1")
@@ -134,3 +249,31 @@ class SchemaWithBlockStatusField(Schema):
 
     with pytest.raises(ValidationError, match="Invalid value for BlockStatus provided"):
         SchemaWithBlockStatusField().load(data)
+
+
+@pytest.mark.parametrize(
+    "data",
+    [{"value": DAMode.L1}, {"value": DAMode.L2}],
+)
+def test_serialize_damode_field(data):
+    serialized = SchemaWithDAModeField().dumps(data)
+    assert f'"value": "{data["value"].name}"' in serialized
+
+
+@pytest.mark.parametrize(
+    "data, expected_deserialized",
+    (
+        ({"value": DAMode.L1.name}, DAMode.L1),
+        ({"value": DAMode.L2.name}, DAMode.L2),
+    ),
+)
+def test_deserialize_damode_field(data, expected_deserialized):
+    deserialized = SchemaWithDAModeField().load(data)
+    assert isinstance(deserialized, dict)
+    assert deserialized["value"] == expected_deserialized
+
+
+def get_uint_error_message(
+    class_type: Union[Type[Uint64], Type[Uint128]], value: Optional[Hash]
+) -> str:
+    return f"Invalid value provided for {class_type.__name__}: {str(value)}"
diff --git a/starknet_py/net/schemas/rpc.py b/starknet_py/net/schemas/rpc.py
