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

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

@@ -1,24 +0,0 @@
-# PayloadSerializer and FunctionSerializationAdapter would mostly be used by users
-from .data_serializers import (
-    ArraySerializer,
-    CairoDataSerializer,
-    FeltSerializer,
-    NamedTupleSerializer,
-    PayloadSerializer,
-    StructSerializer,
-    TupleSerializer,
-    Uint256Serializer,
-)
-from .errors import (
-    CairoSerializerException,
-    InvalidTypeException,
-    InvalidValueException,
-)
-from .factory import (
-    serializer_for_event,
-    serializer_for_function,
-    serializer_for_payload,
-    serializer_for_type,
-)
-from .function_serialization_adapter import FunctionSerializationAdapter
-from .tuple_dataclass import TupleDataclass

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

@@ -1,40 +0,0 @@
-from typing import List
-
-from ..cairo.felt import CairoData
-
-
-class OutOfBoundsError(Exception):
-    def __init__(self, position: int, requested_size: int, remaining_size: int):
-        super().__init__(
-            f"Requested {requested_size} elements, {remaining_size} available."
-        )
-        self.position = position
-        self.requested_size = requested_size
-        self.remaining_len = remaining_size
-
-
-class CalldataReader:
-    _data: List[int]
-    _position: int
-
-    def __init__(self, data: List[int]):
-        self._data = data
-        self._position = 0
-
-    @property
-    def remaining_len(self) -> int:
-        return len(self._data) - self._position
-
-    def read(self, size: int) -> CairoData:
-        if size < 1:
-            raise ValueError("size must be greater than 0")
-
-        if size > self.remaining_len:
-            raise OutOfBoundsError(
-                position=self._position,
-                requested_size=size,
-                remaining_size=self.remaining_len,
-            )
-        data = self._data[self._position : self._position + size]
-        self._position += size
-        return data

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

@@ -1,142 +0,0 @@
-from __future__ import annotations
-
-from abc import ABC
-from contextlib import contextmanager
-from typing import Any, Generator, Iterator, List
-
-from ._calldata_reader import (
-    CairoData,
-    CalldataReader,
-    OutOfBoundsError,
-)
-from .errors import InvalidTypeException, InvalidValueException
-
-
-class Context(ABC):
-    """
-    Holds information about context when (de)serializing data. This is needed to inform what and where went
-    wrong during processing. Every separate (de)serialization should have its own context.
-    """
-
-    _namespace_stack: List[str]
-
-    def __init__(self):
-        self._namespace_stack = []
-
-    @property
-    def current_entity(self):
-        """
-        Name of currently processed entity.
-
-        :return: transformed path.
-        """
-        return ".".join(self._namespace_stack)
-
-    @contextmanager
-    def push_entity(self, name: str) -> Generator:
-        """
-        Manager used for maintaining information about names of (de)serialized types. Wraps some errors with
-        custom errors, adding information about the context.
-
-        :param name: name of (de)serialized entity.
-        """
-        # This ensures the name will be popped if everything is ok. In case an exception is raised we want the stack to
-        # be filled to wrap the error at the end.
-        self._namespace_stack.append(name)
-        yield
-        self._namespace_stack.pop()
-
-    def ensure_valid_value(self, valid: bool, text: str):
-        if not valid:
-            raise InvalidValueException(f"{self._error_prefix}: {text}.")
-
-    def ensure_valid_type(self, value: Any, valid: bool, expected_type: str):
-        if not valid:
-            raise InvalidTypeException(
-                f"{self._error_prefix}: expected {expected_type}, "
-                f"received '{value}' of type '{type(value)}'."
-            )
-
-    @contextmanager
-    def _wrap_errors(self):
-        try:
-            yield
-        except OutOfBoundsError as err:
-            action_name = (
-                f"deserialize '{self.current_entity}'"
-                if self._namespace_stack
-                else "deserialize"
-            )
-            # This way we can precisely inform user what's wrong when reading calldata.
-            raise InvalidValueException(
-                f"Not enough data to {action_name}. "
-                f"Can't read {err.requested_size} values at position {err.position}, {err.remaining_len} available."
-            ) from err
-
-        # Those two are based on ValueError and TypeError, we have to catch them early
-        except (InvalidValueException, InvalidTypeException) as err:
-            raise err
-
-        except ValueError as err:
-            raise InvalidValueException(f"{self._error_prefix}: {err}") from err
-        except TypeError as err:
-            raise InvalidTypeException(f"{self._error_prefix}: {err}") from err
-
-    @property
-    def _error_prefix(self):
-        if not self._namespace_stack:
-            return "Error"
-        return f"Error at path '{self.current_entity}'"
-
-
-class SerializationContext(Context):
-    """
-    Context used during serialization.
-    """
-
-    # Type is iterator, because ContextManager doesn't work with pyright :|
-    # https://github.com/microsoft/pyright/issues/476
-    @classmethod
-    @contextmanager
-    def create(cls) -> Iterator[SerializationContext]:
-        context = cls()
-        with context._wrap_errors():
-            yield context
-
-
-class DeserializationContext(Context):
-    """
-    Context used during deserialization.
-    """
-
-    reader: CalldataReader
-
-    def __init__(self, calldata: CairoData):
-        """
-        Don't use default constructor. Use DeserializationContext.create context manager.
-        """
-        super().__init__()
-        self._namespace_stack = []
-        self.reader = CalldataReader(calldata)
-
-    @classmethod
-    @contextmanager
-    def create(cls, data: CairoData) -> Iterator[DeserializationContext]:
-        context = cls(data)
-        with context._wrap_errors():
-            yield context
-            context._ensure_all_values_read(len(data))
-
-    def _ensure_all_values_read(self, total_len: int):
-        values_not_used = self.reader.remaining_len
-        if values_not_used != 0:
-            # We want to output up to 3 values. It there is more they will be truncated like "0x1,0x1,0x1..."
-            max_values_to_show = 3
-            values_to_show = min(values_not_used, max_values_to_show)
-            example = ",".join(hex(v) for v in self.reader.read(values_to_show))
-            suffix = "..." if values_not_used > max_values_to_show else ""
-
-            raise InvalidValueException(
-                f"Last {values_not_used} values '{example}{suffix}' out of total {total_len} "
-                "values were not used during deserialization."
-            )

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

@@ -1,10 +0,0 @@
-from .array_serializer import ArraySerializer
-from .bool_serializer import BoolSerializer
-from .byte_array_serializer import ByteArraySerializer
-from .cairo_data_serializer import CairoDataSerializer
-from .felt_serializer import FeltSerializer
-from .named_tuple_serializer import NamedTupleSerializer
-from .payload_serializer import PayloadSerializer
-from .struct_serializer import StructSerializer
-from .tuple_serializer import TupleSerializer
-from .uint256_serializer import Uint256Serializer

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

@@ -1,82 +0,0 @@
-# We have to use parametrised type from typing
-from collections import OrderedDict as _OrderedDict
-from typing import Dict, Generator, List, OrderedDict
-
-from .._context import (
-    DeserializationContext,
-    SerializationContext,
-)
-from .cairo_data_serializer import (
-    CairoDataSerializer,
-)
-
-# The actual serialization logic is very similar among all serializers: they either serialize data based on
-# position or their name. Having this logic reused adds indirection, but makes sure proper logic is used everywhere.
-
-
-def deserialize_to_list(
-    deserializers: List[CairoDataSerializer], context: DeserializationContext
-) -> List:
-    """
-    Deserializes data from context to list. This logic is used in every sequential type (arrays and tuples).
-    """
-    result = []
-
-    for index, serializer in enumerate(deserializers):
-        with context.push_entity(f"[{index}]"):
-            result.append(serializer.deserialize_with_context(context))
-
-    return result
-
-
-def deserialize_to_dict(
-    deserializers: OrderedDict[str, CairoDataSerializer],
-    context: DeserializationContext,
-) -> OrderedDict:
-    """
-    Deserializes data from context to dictionary. This logic is used in every type with named fields (structs,
-    named tuples and payloads).
-    """
-    result = _OrderedDict()
-
-    for key, serializer in deserializers.items():
-        with context.push_entity(key):
-            result[key] = serializer.deserialize_with_context(context)
-
-    return result
-
-
-def serialize_from_list(
-    serializers: List[CairoDataSerializer], context: SerializationContext, values: List
-) -> Generator[int, None, None]:
-    """
-    Serializes data from list. This logic is used in every sequential type (arrays and tuples).
-    """
-    context.ensure_valid_value(
-        len(serializers) == len(values),
-        f"expected {len(serializers)} elements, {len(values)} provided",
-    )
-
-    for index, (serializer, value) in enumerate(zip(serializers, values)):
-        with context.push_entity(f"[{index}]"):
-            yield from serializer.serialize_with_context(context, value)
-
-
-def serialize_from_dict(
-    serializers: OrderedDict[str, CairoDataSerializer],
-    context: SerializationContext,
-    values: Dict,
-) -> Generator[int, None, None]:
-    """
-    Serializes data from dict. This logic is used in every type with named fields (structs, named tuples and payloads).
-    """
-    excessive_keys = set(values.keys()).difference(serializers.keys())
-    context.ensure_valid_value(
-        not excessive_keys,
-        f"unexpected keys '{','.join(excessive_keys)}' were provided",
-    )
-
-    for name, serializer in serializers.items():
-        with context.push_entity(name):
-            context.ensure_valid_value(name in values, f"key '{name}' is missing")
-            yield from serializer.serialize_with_context(context, values[name])

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

@@ -1,43 +0,0 @@
-from dataclasses import dataclass
-from typing import Generator, Iterable, List
-
-from .._context import (
-    DeserializationContext,
-    SerializationContext,
-)
-from ..data_serializers._common import (
-    deserialize_to_list,
-    serialize_from_list,
-)
-from ..data_serializers.cairo_data_serializer import (
-    CairoDataSerializer,
-)
-
-
-@dataclass
-class ArraySerializer(CairoDataSerializer[Iterable, List]):
-    """
-    Serializer for arrays. In abi they are represented as a pointer to a type.
-    Can serialize any iterable and prepends its length to resulting list.
-    Deserializes data to a list.
-
-    Examples:
-    [1,2,3] => [3,1,2,3]
-    [] => [0]
-    """
-
-    inner_serializer: CairoDataSerializer
-
-    def deserialize_with_context(self, context: DeserializationContext) -> List:
-        with context.push_entity("len"):
-            [size] = context.reader.read(1)
-
-        return deserialize_to_list([self.inner_serializer] * size, context)
-
-    def serialize_with_context(
-        self, context: SerializationContext, value: List
-    ) -> Generator[int, None, None]:
-        yield len(value)
-        yield from serialize_from_list(
-            [self.inner_serializer] * len(value), context, value
-        )

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

@@ -1,37 +0,0 @@
-from dataclasses import dataclass
-from typing import Generator
-
-from .._context import (
-    Context,
-    DeserializationContext,
-    SerializationContext,
-)
-from .cairo_data_serializer import (
-    CairoDataSerializer,
-)
-
-
-@dataclass
-class BoolSerializer(CairoDataSerializer[bool, int]):
-    """
-    Serializer for boolean.
-    """
-
-    def deserialize_with_context(self, context: DeserializationContext) -> bool:
-        [val] = context.reader.read(1)
-        self._ensure_bool(context, val)
-        return bool(val)
-
-    def serialize_with_context(
-        self, context: SerializationContext, value: bool
-    ) -> Generator[int, None, None]:
-        context.ensure_valid_type(value, isinstance(value, bool), "bool")
-        self._ensure_bool(context, value)
-        yield int(value)
-
-    @staticmethod
-    def _ensure_bool(context: Context, value: int):
-        context.ensure_valid_value(
-            value in [0, 1],
-            f"invalid value '{value}' - must be in [0, 2) range",
-        )

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

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

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

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

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

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

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

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