coinex-api 0.0.6__py3-none-any.whl → 0.0.8__py3-none-any.whl

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

@@ -1,58 +0,0 @@
-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")

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

@@ -1,43 +0,0 @@
-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)

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

@@ -1,40 +0,0 @@
-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."
-        )

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

@@ -1,72 +0,0 @@
-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
-            )
-        )

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

@@ -1,36 +0,0 @@
-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)

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

@@ -1,36 +0,0 @@
-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])

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

@@ -1,76 +0,0 @@
-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)"
-        )

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

@@ -1,100 +0,0 @@
-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) + ")"
-        )

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

@@ -1,32 +0,0 @@
-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

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

@@ -1,10 +0,0 @@
-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."""