bitmart 0.0.116__py3-none-any.whl

bitmart/ccxt/static_dependencies/starknet/serialization/data_serializers/named_tuple_serializer.py

@@ -0,0 +1,58 @@
+from dataclasses import dataclass
+from typing import Dict, Generator, NamedTuple, OrderedDict, Union
+
+from .._context import (
+    DeserializationContext,
+    SerializationContext,
+)
+from ._common import (
+    deserialize_to_dict,
+    serialize_from_dict,
+)
+from .cairo_data_serializer import (
+    CairoDataSerializer,
+)
+from ..tuple_dataclass import TupleDataclass
+
+
+@dataclass
+class NamedTupleSerializer(
+    CairoDataSerializer[Union[Dict, NamedTuple, TupleDataclass], TupleDataclass]
+):
+    """
+    Serializer for tuples with named fields.
+    Can serialize a dictionary, a named tuple and TupleDataclass.
+    Deserializes data to a TupleDataclass.
+
+    Example:
+    {"a": 1, "b": 2} => [1,2]
+    """
+
+    serializers: OrderedDict[str, CairoDataSerializer]
+
+    def deserialize_with_context(
+        self, context: DeserializationContext
+    ) -> TupleDataclass:
+        as_dictionary = deserialize_to_dict(self.serializers, context)
+        return TupleDataclass.from_dict(as_dictionary)
+
+    def serialize_with_context(
+        self,
+        context: SerializationContext,
+        value: Union[Dict, NamedTuple, TupleDataclass],
+    ) -> Generator[int, None, None]:
+        # We can't use isinstance(value, NamedTuple), because there is no NamedTuple type.
+        context.ensure_valid_type(
+            value,
+            isinstance(value, (dict, TupleDataclass)) or self._is_namedtuple(value),
+            "dict, NamedTuple or TupleDataclass",
+        )
+
+        # noinspection PyUnresolvedReferences, PyProtectedMember
+        values: Dict = value if isinstance(value, dict) else value._asdict()
+
+        yield from serialize_from_dict(self.serializers, context, values)
+
+    @staticmethod
+    def _is_namedtuple(value) -> bool:
+        return isinstance(value, tuple) and hasattr(value, "_fields")

bitmart/ccxt/static_dependencies/starknet/serialization/data_serializers/option_serializer.py

@@ -0,0 +1,43 @@
+from dataclasses import dataclass
+from typing import Any, Generator, Optional
+
+from .._context import (
+    DeserializationContext,
+    SerializationContext,
+)
+from .cairo_data_serializer import (
+    CairoDataSerializer,
+)
+
+
+@dataclass
+class OptionSerializer(CairoDataSerializer[Optional[Any], Optional[Any]]):
+    """
+    Serializer for Option type.
+    Can serialize None and common CairoTypes.
+    Deserializes data to None or CairoType.
+
+    Example:
+        None => [1]
+        {"option1": 123, "option2": None} => [0, 123, 1]
+    """
+
+    serializer: CairoDataSerializer
+
+    def deserialize_with_context(
+        self, context: DeserializationContext
+    ) -> Optional[Any]:
+        (is_none,) = context.reader.read(1)
+        if is_none == 1:
+            return None
+
+        return self.serializer.deserialize_with_context(context)
+
+    def serialize_with_context(
+        self, context: SerializationContext, value: Optional[Any]
+    ) -> Generator[int, None, None]:
+        if value is None:
+            yield 1
+        else:
+            yield 0
+            yield from self.serializer.serialize_with_context(context, value)

bitmart/ccxt/static_dependencies/starknet/serialization/data_serializers/output_serializer.py

@@ -0,0 +1,40 @@
+from dataclasses import dataclass, field
+from typing import Dict, Generator, List, Tuple
+
+from .._context import (
+    DeserializationContext,
+    SerializationContext,
+)
+from .cairo_data_serializer import (
+    CairoDataSerializer,
+)
+
+
+@dataclass
+class OutputSerializer(CairoDataSerializer[List, Tuple]):
+    """
+    Serializer for function output.
+    Can't serialize anything.
+    Deserializes data to a Tuple.
+
+    Example:
+        [1, 1, 1] => (340282366920938463463374607431768211457)
+    """
+
+    serializers: List[CairoDataSerializer] = field(init=True)
+
+    def deserialize_with_context(self, context: DeserializationContext) -> Tuple:
+        result = []
+
+        for index, serializer in enumerate(self.serializers):
+            with context.push_entity("output[" + str(index) + "]"):
+                result.append(serializer.deserialize_with_context(context))
+
+        return tuple(result)
+
+    def serialize_with_context(
+        self, context: SerializationContext, value: Dict
+    ) -> Generator[int, None, None]:
+        raise ValueError(
+            "Output serializer can't be used to transform python data into calldata."
+        )

bitmart/ccxt/static_dependencies/starknet/serialization/data_serializers/payload_serializer.py

@@ -0,0 +1,72 @@
+from collections import OrderedDict as _OrderedDict
+from dataclasses import InitVar, dataclass, field
+from typing import Dict, Generator, OrderedDict
+
+from .._context import (
+    DeserializationContext,
+    SerializationContext,
+)
+from ._common import (
+    deserialize_to_dict,
+    serialize_from_dict,
+)
+from .array_serializer import ArraySerializer
+from .cairo_data_serializer import (
+    CairoDataSerializer,
+)
+from .felt_serializer import FeltSerializer
+from ..tuple_dataclass import TupleDataclass
+
+SIZE_SUFFIX = "_len"
+SIZE_SUFFIX_LEN = len(SIZE_SUFFIX)
+
+
+@dataclass
+class PayloadSerializer(CairoDataSerializer[Dict, TupleDataclass]):
+    """
+    Serializer for payloads like function arguments/function outputs/events.
+    Can serialize a dictionary.
+    Deserializes data to a TupleDataclass.
+
+    Example:
+    {"a": 1, "b": 2} => [1,2]
+    """
+
+    # Value present only in constructor.
+    # We don't want to mutate the serializers received in constructor.
+    input_serializers: InitVar[OrderedDict[str, CairoDataSerializer]]
+
+    serializers: OrderedDict[str, CairoDataSerializer] = field(init=False)
+
+    def __post_init__(self, input_serializers):
+        """
+        ABI adds ARG_len for every argument ARG that is an array. We parse length as a part of ArraySerializer, so we
+        need to remove those lengths from args.
+        """
+        self.serializers = _OrderedDict(
+            (key, serializer)
+            for key, serializer in input_serializers.items()
+            if not self._is_len_arg(key, input_serializers)
+        )
+
+    def deserialize_with_context(
+        self, context: DeserializationContext
+    ) -> TupleDataclass:
+        as_dictionary = deserialize_to_dict(self.serializers, context)
+        return TupleDataclass.from_dict(as_dictionary)
+
+    def serialize_with_context(
+        self, context: SerializationContext, value: Dict
+    ) -> Generator[int, None, None]:
+        yield from serialize_from_dict(self.serializers, context, value)
+
+    @staticmethod
+    def _is_len_arg(arg_name: str, serializers: Dict[str, CairoDataSerializer]) -> bool:
+        return (
+            arg_name.endswith(SIZE_SUFFIX)
+            and isinstance(serializers[arg_name], FeltSerializer)
+            # There is an ArraySerializer under key that is arg_name without the size suffix
+            and isinstance(
+                serializers.get(arg_name[:-SIZE_SUFFIX_LEN]), ArraySerializer
+            )
+        )

bitmart/ccxt/static_dependencies/starknet/serialization/data_serializers/struct_serializer.py

@@ -0,0 +1,36 @@
+from dataclasses import dataclass
+from typing import Dict, Generator, OrderedDict
+
+from .._context import (
+    DeserializationContext,
+    SerializationContext,
+)
+from ._common import (
+    deserialize_to_dict,
+    serialize_from_dict,
+)
+from .cairo_data_serializer import (
+    CairoDataSerializer,
+)
+
+
+@dataclass
+class StructSerializer(CairoDataSerializer[Dict, Dict]):
+    """
+    Serializer of custom structures.
+    Can serialize a dictionary.
+    Deserializes data to a dictionary.
+
+    Example:
+    {"a": 1, "b": 2} => [1,2]
+    """
+
+    serializers: OrderedDict[str, CairoDataSerializer]
+
+    def deserialize_with_context(self, context: DeserializationContext) -> Dict:
+        return deserialize_to_dict(self.serializers, context)
+
+    def serialize_with_context(
+        self, context: SerializationContext, value: Dict
+    ) -> Generator[int, None, None]:
+        yield from serialize_from_dict(self.serializers, context, value)

bitmart/ccxt/static_dependencies/starknet/serialization/data_serializers/tuple_serializer.py

@@ -0,0 +1,36 @@
+from dataclasses import dataclass
+from typing import Generator, Iterable, List, Tuple
+
+from .._context import (
+    DeserializationContext,
+    SerializationContext,
+)
+from ._common import (
+    deserialize_to_list,
+    serialize_from_list,
+)
+from .cairo_data_serializer import (
+    CairoDataSerializer,
+)
+
+
+@dataclass
+class TupleSerializer(CairoDataSerializer[Iterable, Tuple]):
+    """
+    Serializer for tuples without named fields.
+    Can serialize any iterable.
+    Deserializes data to a python tuple.
+
+    Example:
+    (1,2,(3,4)) => [1,2,3,4]
+    """
+
+    serializers: List[CairoDataSerializer]
+
+    def deserialize_with_context(self, context: DeserializationContext) -> Tuple:
+        return tuple(deserialize_to_list(self.serializers, context))
+
+    def serialize_with_context(
+        self, context: SerializationContext, value: Iterable
+    ) -> Generator[int, None, None]:
+        yield from serialize_from_list(self.serializers, context, [*value])

bitmart/ccxt/static_dependencies/starknet/serialization/data_serializers/uint256_serializer.py

@@ -0,0 +1,76 @@
+from dataclasses import dataclass
+from typing import Generator, TypedDict, Union
+
+from ...cairo.felt import uint256_range_check
+from .._context import (
+    Context,
+    DeserializationContext,
+    SerializationContext,
+)
+from .cairo_data_serializer import (
+    CairoDataSerializer,
+)
+
+U128_UPPER_BOUND = 2**128
+
+
+class Uint256Dict(TypedDict):
+    low: int
+    high: int
+
+
+@dataclass
+class Uint256Serializer(CairoDataSerializer[Union[int, Uint256Dict], int]):
+    """
+    Serializer of Uint256. In Cairo it is represented by structure {low: Uint128, high: Uint128}.
+    Can serialize an int.
+    Deserializes data to an int.
+
+    Examples:
+    0 => [0,0]
+    1 => [1,0]
+    2**128 => [0,1]
+    3 + 2**128 => [3,1]
+    """
+
+    def deserialize_with_context(self, context: DeserializationContext) -> int:
+        [low, high] = context.reader.read(2)
+
+        # Checking if resulting value is in [0, 2**256) range is not enough. Uint256 should be made of two uint128.
+        with context.push_entity("low"):
+            self._ensure_valid_uint128(low, context)
+        with context.push_entity("high"):
+            self._ensure_valid_uint128(high, context)
+
+        return (high << 128) + low
+
+    def serialize_with_context(
+        self, context: SerializationContext, value: Union[int, Uint256Dict]
+    ) -> Generator[int, None, None]:
+        context.ensure_valid_type(value, isinstance(value, (int, dict)), "int or dict")
+        if isinstance(value, int):
+            yield from self._serialize_from_int(value)
+        else:
+            yield from self._serialize_from_dict(context, value)
+
+    @staticmethod
+    def _serialize_from_int(value: int) -> Generator[int, None, None]:
+        uint256_range_check(value)
+        result = (value % 2**128, value // 2**128)
+        yield from result
+
+    def _serialize_from_dict(
+        self, context: SerializationContext, value: Uint256Dict
+    ) -> Generator[int, None, None]:
+        with context.push_entity("low"):
+            self._ensure_valid_uint128(value["low"], context)
+            yield value["low"]
+        with context.push_entity("high"):
+            self._ensure_valid_uint128(value["high"], context)
+            yield value["high"]
+
+    @staticmethod
+    def _ensure_valid_uint128(value: int, context: Context):
+        context.ensure_valid_value(
+            0 <= value < U128_UPPER_BOUND, "expected value in range [0;2**128)"
+        )

bitmart/ccxt/static_dependencies/starknet/serialization/data_serializers/uint_serializer.py

@@ -0,0 +1,100 @@
+from dataclasses import dataclass
+from typing import Generator, TypedDict, Union
+
+from ...cairo.felt import uint256_range_check
+from .._context import (
+    Context,
+    DeserializationContext,
+    SerializationContext,
+)
+from .cairo_data_serializer import (
+    CairoDataSerializer,
+)
+
+
+class Uint256Dict(TypedDict):
+    low: int
+    high: int
+
+
+@dataclass
+class UintSerializer(CairoDataSerializer[Union[int, Uint256Dict], int]):
+    """
+    Serializer of uint. In Cairo there are few uints (u8, ..., u128 and u256).
+    u256 is represented by structure {low: u128, high: u128}.
+    Can serialize an int and dict.
+    Deserializes data to an int.
+
+    Examples:
+        if bits < 256:
+            0 => [0]
+            1 => [1]
+            2**128-1 => [2**128-1]
+        else:
+            0 => [0,0]
+            1 => [1,0]
+            2**128 => [0,1]
+            3 + 2**128 => [3,1]
+    """
+
+    bits: int
+
+    def deserialize_with_context(self, context: DeserializationContext) -> int:
+        if self.bits < 256:
+            (uint,) = context.reader.read(1)
+            with context.push_entity("uint" + str(self.bits)):
+                self._ensure_valid_uint(uint, context, self.bits)
+
+            return uint
+
+        [low, high] = context.reader.read(2)
+
+        # Checking if resulting value is in [0, 2**256) range is not enough. Uint256 should be made of two uint128.
+        with context.push_entity("low"):
+            self._ensure_valid_uint(low, context, bits=128)
+        with context.push_entity("high"):
+            self._ensure_valid_uint(high, context, bits=128)
+
+        return (high << 128) + low
+
+    def serialize_with_context(
+        self, context: SerializationContext, value: Union[int, Uint256Dict]
+    ) -> Generator[int, None, None]:
+        context.ensure_valid_type(value, isinstance(value, (int, dict)), "int or dict")
+        if isinstance(value, int):
+            yield from self._serialize_from_int(value, context, self.bits)
+        else:
+            yield from self._serialize_from_dict(context, value)
+
+    @staticmethod
+    def _serialize_from_int(
+        value: int, context: SerializationContext, bits: int
+    ) -> Generator[int, None, None]:
+        if bits < 256:
+            UintSerializer._ensure_valid_uint(value, context, bits)
+
+            yield value
+        else:
+            uint256_range_check(value)
+
+            result = (value % 2**128, value >> 128)
+            yield from result
+
+    def _serialize_from_dict(
+        self, context: SerializationContext, value: Uint256Dict
+    ) -> Generator[int, None, None]:
+        with context.push_entity("low"):
+            self._ensure_valid_uint(value["low"], context, bits=128)
+            yield value["low"]
+        with context.push_entity("high"):
+            self._ensure_valid_uint(value["high"], context, bits=128)
+            yield value["high"]
+
+    @staticmethod
+    def _ensure_valid_uint(value: int, context: Context, bits: int):
+        """
+        Ensures that value is a valid uint on `bits` bits.
+        """
+        context.ensure_valid_value(
+            0 <= value < 2**bits, "expected value in range [0;2**" + str(bits) + ")"
+        )

bitmart/ccxt/static_dependencies/starknet/serialization/data_serializers/unit_serializer.py

@@ -0,0 +1,32 @@
+from dataclasses import dataclass
+from typing import Any, Generator, Optional
+
+from .._context import (
+    DeserializationContext,
+    SerializationContext,
+)
+from .cairo_data_serializer import (
+    CairoDataSerializer,
+)
+
+
+@dataclass
+class UnitSerializer(CairoDataSerializer[None, None]):
+    """
+    Serializer for unit type.
+    Can only serialize None.
+    Deserializes data to None.
+
+    Example:
+        [] => None
+    """
+
+    def deserialize_with_context(self, context: DeserializationContext) -> None:
+        return None
+
+    def serialize_with_context(
+        self, context: SerializationContext, value: Optional[Any]
+    ) -> Generator[None, None, None]:
+        if value is not None:
+            raise ValueError("Can only serialize `None`.")
+        yield None

bitmart/ccxt/static_dependencies/starknet/serialization/errors.py

@@ -0,0 +1,10 @@
+class CairoSerializerException(Exception):
+    """Exception thrown by CairoSerializer."""
+
+
+class InvalidTypeException(CairoSerializerException, TypeError):
+    """Exception thrown when invalid type was provided."""
+
+
+class InvalidValueException(CairoSerializerException, ValueError):
+    """Exception thrown when invalid value was provided."""