ccxt 4.2.77__py2.py3-none-any.whl → 4.4.48__py2.py3-none-any.whl

ccxt/static_dependencies/starknet/serialization/data_serializers/byte_array_serializer.py

@@ -0,0 +1,66 @@
+from dataclasses import dataclass
+from typing import Generator
+
+from ...cairo.felt import decode_shortstring, encode_shortstring
+from .._context import (
+    DeserializationContext,
+    SerializationContext,
+)
+from ._common import (
+    deserialize_to_list,
+    serialize_from_list,
+)
+from .cairo_data_serializer import (
+    CairoDataSerializer,
+)
+from .felt_serializer import FeltSerializer
+
+BYTES_31_SIZE = 31
+
+
+@dataclass
+class ByteArraySerializer(CairoDataSerializer[str, str]):
+    """
+    Serializer for ByteArrays. Serializes to and deserializes from str values.
+
+    Examples:
+    "" => [0,0,0]
+    "hello" => [0,448378203247,5]
+    """
+
+    def deserialize_with_context(self, context: DeserializationContext) -> str:
+        with context.push_entity("data_array_len"):
+            [size] = context.reader.read(1)
+
+        data = deserialize_to_list([FeltSerializer()] * size, context)
+
+        with context.push_entity("pending_word"):
+            [pending_word] = context.reader.read(1)
+
+        with context.push_entity("pending_word_len"):
+            [pending_word_len] = context.reader.read(1)
+
+        pending_word = decode_shortstring(pending_word)
+        context.ensure_valid_value(
+            len(pending_word) == pending_word_len,
+            f"Invalid length {pending_word_len} for pending word {pending_word}",
+        )
+
+        data_joined = "".join(map(decode_shortstring, data))
+        return data_joined + pending_word
+
+    def serialize_with_context(
+        self, context: SerializationContext, value: str
+    ) -> Generator[int, None, None]:
+        context.ensure_valid_type(value, isinstance(value, str), "str")
+        data = [
+            value[i : i + BYTES_31_SIZE] for i in range(0, len(value), BYTES_31_SIZE)
+        ]
+        pending_word = (
+            "" if len(data) == 0 or len(data[-1]) == BYTES_31_SIZE else data.pop(-1)
+        )
+
+        yield len(data)
+        yield from serialize_from_list([FeltSerializer()] * len(data), context, data)
+        yield encode_shortstring(pending_word)
+        yield len(pending_word)

ccxt/static_dependencies/starknet/serialization/data_serializers/cairo_data_serializer.py

@@ -0,0 +1,71 @@
+from abc import ABC, abstractmethod
+from typing import Generator, Generic, List, TypeVar
+
+from .._calldata_reader import CairoData
+from .._context import (
+    DeserializationContext,
+    SerializationContext,
+)
+
+# Python type that is accepted by a serializer
+# pylint: disable=invalid-name
+SerializationType = TypeVar("SerializationType")
+
+# Python type that will be returned from a serializer. Often same as SerializationType.
+# pylint: disable=invalid-name
+DeserializationType = TypeVar("DeserializationType")
+
+
+class CairoDataSerializer(ABC, Generic[SerializationType, DeserializationType]):
+    """
+    Base class for serializing/deserializing data to/from calldata.
+    """
+
+    def deserialize(self, data: List[int]) -> DeserializationType:
+        """
+        Transform calldata into python value.
+
+        :param data: calldata to deserialize.
+        :return: defined DeserializationType.
+        """
+        with DeserializationContext.create(data) as context:
+            return self.deserialize_with_context(context)
+
+    def serialize(self, data: SerializationType) -> CairoData:
+        """
+        Transform python data into calldata.
+
+        :param data: data to serialize.
+        :return: calldata.
+        """
+        with SerializationContext.create() as context:
+            serialized_data = list(self.serialize_with_context(context, data))
+
+            return self.remove_units_from_serialized_data(serialized_data)
+
+    @abstractmethod
+    def deserialize_with_context(
+        self, context: DeserializationContext
+    ) -> DeserializationType:
+        """
+        Transform calldata into python value.
+
+        :param context: context of this deserialization.
+        :return: defined DeserializationType.
+        """
+
+    @abstractmethod
+    def serialize_with_context(
+        self, context: SerializationContext, value: SerializationType
+    ) -> Generator[int, None, None]:
+        """
+        Transform python value into calldata.
+
+        :param context: context of this serialization.
+        :param value: python value to serialize.
+        :return: defined SerializationType.
+        """
+
+    @staticmethod
+    def remove_units_from_serialized_data(serialized_data: List) -> List:
+        return [x for x in serialized_data if x is not None]

ccxt/static_dependencies/starknet/serialization/data_serializers/enum_serializer.py

@@ -0,0 +1,71 @@
+from dataclasses import dataclass
+from typing import Dict, Generator, OrderedDict, Tuple, Union
+
+from .._context import (
+    DeserializationContext,
+    SerializationContext,
+)
+from .cairo_data_serializer import (
+    CairoDataSerializer,
+)
+from ..tuple_dataclass import TupleDataclass
+
+
+@dataclass
+class EnumSerializer(CairoDataSerializer[Union[Dict, TupleDataclass], TupleDataclass]):
+    """
+    Serializer of enums.
+    Can serialize a dictionary and TupleDataclass.
+    Deserializes data to a TupleDataclass.
+
+    Example:
+        enum MyEnum {
+          a: u128,
+          b: u128
+        }
+
+        {"a": 1} => [0, 1]
+        {"b": 100} => [1, 100]
+        TupleDataclass(variant='a', value=100) => [0, 100]
+    """
+
+    serializers: OrderedDict[str, CairoDataSerializer]
+
+    def deserialize_with_context(
+        self, context: DeserializationContext
+    ) -> TupleDataclass:
+        [variant_index] = context.reader.read(1)
+        variant_name, serializer = self._get_variant(variant_index)
+
+        with context.push_entity("enum.variant: " + variant_name):
+            result_dict = {
+                "variant": variant_name,
+                "value": serializer.deserialize_with_context(context),
+            }
+
+        return TupleDataclass.from_dict(result_dict)
+
+    def serialize_with_context(
+        self, context: SerializationContext, value: Union[Dict, TupleDataclass]
+    ) -> Generator[int, None, None]:
+        if isinstance(value, Dict):
+            items = list(value.items())
+            if len(items) != 1:
+                raise ValueError(
+                    "Can serialize only one enum variant, got: " + str(len(items))
+                )
+
+            variant_name, variant_value = items[0]
+        else:
+            variant_name, variant_value = value
+
+        yield self._get_variant_index(variant_name)
+        yield from self.serializers[variant_name].serialize_with_context(
+            context, variant_value
+        )
+
+    def _get_variant(self, variant_index: int) -> Tuple[str, CairoDataSerializer]:
+        return list(self.serializers.items())[variant_index]
+
+    def _get_variant_index(self, variant_name: str) -> int:
+        return list(self.serializers.keys()).index(variant_name)

ccxt/static_dependencies/starknet/serialization/data_serializers/felt_serializer.py

@@ -0,0 +1,50 @@
+import warnings
+from dataclasses import dataclass
+from typing import Generator
+
+from ...cairo.felt import encode_shortstring, is_in_felt_range
+from ...constants import FIELD_PRIME
+from .._context import (
+    Context,
+    DeserializationContext,
+    SerializationContext,
+)
+from .cairo_data_serializer import (
+    CairoDataSerializer,
+)
+
+
+@dataclass
+class FeltSerializer(CairoDataSerializer[int, int]):
+    """
+    Serializer for field element. At the time of writing it is the only existing numeric type.
+    """
+
+    def deserialize_with_context(self, context: DeserializationContext) -> int:
+        [val] = context.reader.read(1)
+        self._ensure_felt(context, val)
+        return val
+
+    def serialize_with_context(
+        self, context: SerializationContext, value: int
+    ) -> Generator[int, None, None]:
+        if isinstance(value, str):
+            warnings.warn(
+                "Serializing shortstrings in FeltSerializer is deprecated. "
+                "Use starknet_py.cairo.felt.encode_shortstring instead.",
+                category=DeprecationWarning,
+            )
+            value = encode_shortstring(value)
+            yield value
+            return
+
+        context.ensure_valid_type(value, isinstance(value, int), "int")
+        self._ensure_felt(context, value)
+        yield value
+
+    @staticmethod
+    def _ensure_felt(context: Context, value: int):
+        context.ensure_valid_value(
+            is_in_felt_range(value),
+            f"invalid value '{value}' - must be in [0, {FIELD_PRIME}) range",
+        )

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")

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)

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."
+        )

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
+            )
+        )

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)

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])

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)"
+        )