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

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

@@ -1,229 +0,0 @@
-from __future__ import annotations
-
-from collections import OrderedDict
-from typing import Dict, List, Union
-
-from ..abi.v0 import Abi as AbiV0
-from ..abi.v1 import Abi as AbiV1
-from ..abi.v2 import Abi as AbiV2
-from ..cairo.data_types import (
-    ArrayType,
-    BoolType,
-    CairoType,
-    EnumType,
-    EventType,
-    FeltType,
-    NamedTupleType,
-    OptionType,
-    StructType,
-    TupleType,
-    UintType,
-    UnitType,
-)
-from .data_serializers import (
-    BoolSerializer,
-    ByteArraySerializer,
-)
-from .data_serializers.array_serializer import ArraySerializer
-from .data_serializers.cairo_data_serializer import (
-    CairoDataSerializer,
-)
-from .data_serializers.enum_serializer import EnumSerializer
-from .data_serializers.felt_serializer import FeltSerializer
-from .data_serializers.named_tuple_serializer import (
-    NamedTupleSerializer,
-)
-from .data_serializers.option_serializer import (
-    OptionSerializer,
-)
-from .data_serializers.output_serializer import (
-    OutputSerializer,
-)
-from .data_serializers.payload_serializer import (
-    PayloadSerializer,
-)
-from .data_serializers.struct_serializer import (
-    StructSerializer,
-)
-from .data_serializers.tuple_serializer import TupleSerializer
-from .data_serializers.uint256_serializer import (
-    Uint256Serializer,
-)
-from .data_serializers.uint_serializer import UintSerializer
-from .data_serializers.unit_serializer import UnitSerializer
-from .errors import InvalidTypeException
-from .function_serialization_adapter import (
-    FunctionSerializationAdapter,
-    FunctionSerializationAdapterV1,
-)
-
-_uint256_type = StructType("Uint256", OrderedDict(low=FeltType(), high=FeltType()))
-_byte_array_type = StructType(
-    "core::byte_array::ByteArray",
-    OrderedDict(
-        data=ArrayType(FeltType()),
-        pending_word=FeltType(),
-        pending_word_len=UintType(bits=32),
-    ),
-)
-
-
-def serializer_for_type(cairo_type: CairoType) -> CairoDataSerializer:
-    """
-    Create a serializer for cairo type.
-
-    :param cairo_type: CairoType.
-    :return: CairoDataSerializer.
-    """
-    # pylint: disable=too-many-return-statements, too-many-branches
-    if isinstance(cairo_type, FeltType):
-        return FeltSerializer()
-
-    if isinstance(cairo_type, BoolType):
-        return BoolSerializer()
-
-    if isinstance(cairo_type, StructType):
-        # Special case: Uint256 is represented as struct
-        if cairo_type == _uint256_type:
-            return Uint256Serializer()
-
-        if cairo_type == _byte_array_type:
-            return ByteArraySerializer()
-
-        return StructSerializer(
-            OrderedDict(
-                (name, serializer_for_type(member_type))
-                for name, member_type in cairo_type.types.items()
-            )
-        )
-
-    if isinstance(cairo_type, ArrayType):
-        return ArraySerializer(serializer_for_type(cairo_type.inner_type))
-
-    if isinstance(cairo_type, TupleType):
-        return TupleSerializer(
-            [serializer_for_type(member) for member in cairo_type.types]
-        )
-
-    if isinstance(cairo_type, NamedTupleType):
-        return NamedTupleSerializer(
-            OrderedDict(
-                (name, serializer_for_type(member_type))
-                for name, member_type in cairo_type.types.items()
-            )
-        )
-
-    if isinstance(cairo_type, UintType):
-        return UintSerializer(bits=cairo_type.bits)
-
-    if isinstance(cairo_type, OptionType):
-        return OptionSerializer(serializer_for_type(cairo_type.type))
-
-    if isinstance(cairo_type, UnitType):
-        return UnitSerializer()
-
-    if isinstance(cairo_type, EnumType):
-        return EnumSerializer(
-            OrderedDict(
-                (name, serializer_for_type(variant_type))
-                for name, variant_type in cairo_type.variants.items()
-            )
-        )
-    if isinstance(cairo_type, EventType):
-        return serializer_for_payload(cairo_type.types)
-
-    raise InvalidTypeException(f"Received unknown Cairo type '{cairo_type}'.")
-
-
-# We don't want to require users to use OrderedDict. Regular python requires order since python 3.7.
-def serializer_for_payload(payload: Dict[str, CairoType]) -> PayloadSerializer:
-    """
-    Create PayloadSerializer for types listed in a dictionary. Please note that the order of fields in the dict is
-    very important. Make sure the keys are provided in the right order.
-
-    :param payload: dictionary with cairo types.
-    :return: PayloadSerializer that can be used to (de)serialize events/function calls.
-    """
-    return PayloadSerializer(
-        OrderedDict(
-            (name, serializer_for_type(cairo_type))
-            for name, cairo_type in payload.items()
-        )
-    )
-
-
-def serializer_for_outputs(payload: List[CairoType]) -> OutputSerializer:
-    """
-    Create OutputSerializer for types in list. Please note that the order of fields in the list is
-    very important. Make sure the types are provided in the right order.
-
-    :param payload: list with cairo types.
-    :return: OutputSerializer that can be used to deserialize function outputs.
-    """
-    return OutputSerializer(
-        serializers=[serializer_for_type(cairo_type) for cairo_type in payload]
-    )
-
-
-EventV0 = AbiV0.Event
-EventV1 = AbiV1.Event
-EventV2 = EventType
-
-
-def serializer_for_event(event: EventV0 | EventV1 | EventV2) -> PayloadSerializer:
-    """
-    Create serializer for an event.
-
-    :param event: parsed event.
-    :return: PayloadSerializer that can be used to (de)serialize events.
-    """
-    if isinstance(event, EventV0):
-        return serializer_for_payload(event.data)
-    if isinstance(event, EventV1):
-        return serializer_for_payload(event.inputs)
-    return serializer_for_payload(event.types)
-
-
-def serializer_for_function(
-    abi_function: AbiV0.Function,
-) -> FunctionSerializationAdapter:
-    """
-    Create FunctionSerializationAdapter for serializing function inputs and deserializing function outputs.
-
-    :param abi_function: parsed function's abi.
-    :return: FunctionSerializationAdapter.
-    """
-    return FunctionSerializationAdapter(
-        inputs_serializer=serializer_for_payload(abi_function.inputs),
-        outputs_deserializer=serializer_for_payload(abi_function.outputs),
-    )
-
-
-def serializer_for_function_v1(
-    abi_function: Union[AbiV1.Function, AbiV2.Function],
-) -> FunctionSerializationAdapter:
-    """
-    Create FunctionSerializationAdapter for serializing function inputs and deserializing function outputs.
-
-    :param abi_function: parsed function's abi.
-    :return: FunctionSerializationAdapter.
-    """
-    return FunctionSerializationAdapterV1(
-        inputs_serializer=serializer_for_payload(abi_function.inputs),
-        outputs_deserializer=serializer_for_outputs(abi_function.outputs),
-    )
-
-
-def serializer_for_constructor_v2(
-    abi_function: AbiV2.Constructor,
-) -> FunctionSerializationAdapter:
-    """
-    Create FunctionSerializationAdapter for serializing constructor inputs.
-
-    :param abi_function: parsed constructor's abi.
-    :return: FunctionSerializationAdapter.
-    """
-    return FunctionSerializationAdapterV1(
-        inputs_serializer=serializer_for_payload(abi_function.inputs),
-        outputs_deserializer=serializer_for_outputs([]),
-    )

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

@@ -1,110 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass, field
-from typing import Dict, List, Set, Tuple
-
-from ..cairo.felt import CairoData
-from .data_serializers.output_serializer import (
-    OutputSerializer,
-)
-from .data_serializers.payload_serializer import (
-    PayloadSerializer,
-)
-from .errors import InvalidTypeException
-from .tuple_dataclass import TupleDataclass
-
-
-@dataclass
-class FunctionSerializationAdapter:
-    """
-    Class serializing ``*args`` and ``**kwargs`` by adapting them to function inputs.
-    """
-
-    inputs_serializer: PayloadSerializer
-    outputs_deserializer: PayloadSerializer
-
-    expected_args: Tuple[str] = field(init=False)
-
-    def __post_init__(self):
-        self.expected_args = tuple(
-            self.inputs_serializer.serializers.keys()
-        )  # pyright: ignore
-
-    def serialize(self, *args, **kwargs) -> CairoData:
-        """
-        Method using args and kwargs to match members and serialize them separately.
-
-        :return: Members serialized separately in SerializedPayload.
-        """
-        named_arguments = self._merge_arguments(args, kwargs)
-        return self.inputs_serializer.serialize(named_arguments)
-
-    def deserialize(self, data: List[int]) -> TupleDataclass:
-        """
-        Deserializes data into TupleDataclass containing python representations.
-
-        :return: cairo data.
-        """
-        return self.outputs_deserializer.deserialize(data)
-
-    def _merge_arguments(self, args: Tuple, kwargs: Dict) -> Dict:
-        """
-        Merges positional and keyed arguments.
-        """
-        # After this line we know that len(args) <= len(self.expected_args)
-        self._ensure_no_unnecessary_positional_args(args)
-
-        named_arguments = dict(kwargs)
-        for arg, input_name in zip(args, self.expected_args):
-            if input_name in kwargs:
-                raise InvalidTypeException(
-                    f"Both positional and named argument provided for '{input_name}'."
-                )
-            named_arguments[input_name] = arg
-
-        expected_args = set(self.expected_args)
-        provided_args = set(named_arguments.keys())
-
-        # named_arguments might have unnecessary arguments coming from kwargs (we ensure that
-        # len(args) <= len(self.expected_args) above)
-        self._ensure_no_unnecessary_args(expected_args, provided_args)
-
-        # there might be some argument missing (not provided)
-        self._ensure_no_missing_args(expected_args, provided_args)
-
-        return named_arguments
-
-    def _ensure_no_unnecessary_positional_args(self, args: Tuple):
-        if len(args) > len(self.expected_args):
-            raise InvalidTypeException(
-                f"Provided {len(args)} positional arguments, {len(self.expected_args)} possible."
-            )
-
-    @staticmethod
-    def _ensure_no_unnecessary_args(expected_args: Set[str], provided_args: Set[str]):
-        excessive_arguments = provided_args - expected_args
-        if excessive_arguments:
-            raise InvalidTypeException(
-                f"Unnecessary named arguments provided: '{', '.join(excessive_arguments)}'."
-            )
-
-    @staticmethod
-    def _ensure_no_missing_args(expected_args: Set[str], provided_args: Set[str]):
-        missing_arguments = expected_args - provided_args
-        if missing_arguments:
-            raise InvalidTypeException(
-                f"Missing arguments: '{', '.join(missing_arguments)}'."
-            )
-
-
-@dataclass
-class FunctionSerializationAdapterV1(FunctionSerializationAdapter):
-    outputs_deserializer: OutputSerializer
-
-    def deserialize(self, data: List[int]) -> Tuple:
-        """
-        Deserializes data into TupleDataclass containing python representations.
-
-        :return: cairo data.
-        """
-        return self.outputs_deserializer.deserialize(data)

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

@@ -1,59 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass, fields, make_dataclass
-from typing import Dict, Optional, Tuple
-
-
-@dataclass(frozen=True, eq=False)
-class TupleDataclass:
-    """
-    Dataclass that behaves like a tuple at the same time. Used when data has defined order and names.
-    For instance in case of named tuples or function responses.
-    """
-
-    # getattr is called when attribute is not found in object. For instance when using object.unknown_attribute.
-    # This way pyright will know that there might be some arguments it doesn't know about and will stop complaining
-    # about some fields that don't exist statically.
-    def __getattr__(self, item):
-        # This should always fail - only attributes that don't exist end up in here.
-        # We use __getattribute__ to get the native error.
-        return super().__getattribute__(item)
-
-    def __getitem__(self, item: int):
-        field = fields(self)[item]
-        return getattr(self, field.name)
-
-    def __iter__(self):
-        return (getattr(self, field.name) for field in fields(self))
-
-    def as_tuple(self) -> Tuple:
-        """
-        Creates a regular tuple from TupleDataclass.
-        """
-        return tuple(self)
-
-    def as_dict(self) -> Dict:
-        """
-        Creates a regular dict from TupleDataclass.
-        """
-        return {field.name: getattr(self, field.name) for field in fields(self)}
-
-    # Added for backward compatibility with previous implementation based on NamedTuple
-    def _asdict(self):
-        return self.as_dict()
-
-    def __eq__(self, other):
-        if isinstance(other, TupleDataclass):
-            return self.as_tuple() == other.as_tuple()
-        return self.as_tuple() == other
-
-    @staticmethod
-    def from_dict(data: Dict, *, name: Optional[str] = None) -> TupleDataclass:
-        result_class = make_dataclass(
-            name or "TupleDataclass",
-            fields=[(key, type(value)) for key, value in data.items()],
-            bases=(TupleDataclass,),
-            frozen=True,
-            eq=False,
-        )
-        return result_class(**data)

coinex_api/ccxt/static_dependencies/starknet/utils/constructor_args_translator.py

@@ -1,86 +0,0 @@
-from typing import List, Optional, Union
-
-from ..abi.v2 import shape as ShapeV2
-from ..abi.v0 import AbiParser as AbiParserV0
-from ..abi.v1 import AbiParser as AbiParserV1
-from ..abi.v2 import AbiParser as AbiParserV2
-from ..serialization import (
-    FunctionSerializationAdapter,
-    serializer_for_function,
-)
-from ..serialization.factory import (
-    serializer_for_constructor_v2,
-    serializer_for_function_v1,
-)
-
-
-def translate_constructor_args(
-    abi: List, constructor_args: Optional[Union[List, dict]], *, cairo_version: int = 1
-) -> List[int]:
-    serializer = (
-        _get_constructor_serializer_v1(abi)
-        if cairo_version == 1
-        else _get_constructor_serializer_v0(abi)
-    )
-
-    if serializer is None or len(serializer.inputs_serializer.serializers) == 0:
-        return []
-
-    if not constructor_args:
-        raise ValueError(
-            "Provided contract has a constructor and no arguments were provided."
-        )
-
-    args, kwargs = (
-        ([], constructor_args)
-        if isinstance(constructor_args, dict)
-        else (constructor_args, {})
-    )
-    return serializer.serialize(*args, **kwargs)
-
-
-def _get_constructor_serializer_v1(abi: List) -> Optional[FunctionSerializationAdapter]:
-    if _is_abi_v2(abi):
-        parsed = AbiParserV2(abi).parse()
-        constructor = parsed.constructor
-
-        if constructor is None or not constructor.inputs:
-            return None
-
-        return serializer_for_constructor_v2(constructor)
-
-    parsed = AbiParserV1(abi).parse()
-    constructor = parsed.functions.get("constructor", None)
-
-    # Constructor might not accept any arguments
-    if constructor is None or not constructor.inputs:
-        return None
-
-    return serializer_for_function_v1(constructor)
-
-
-def _is_abi_v2(abi: List) -> bool:
-    for entry in abi:
-        if entry["type"] in [
-            ShapeV2.CONSTRUCTOR_ENTRY,
-            ShapeV2.L1_HANDLER_ENTRY,
-            ShapeV2.INTERFACE_ENTRY,
-            ShapeV2.IMPL_ENTRY,
-        ]:
-            return True
-        if entry["type"] == ShapeV2.EVENT_ENTRY:
-            if "inputs" in entry:
-                return False
-            if "kind" in entry:
-                return True
-    return False
-
-
-def _get_constructor_serializer_v0(abi: List) -> Optional[FunctionSerializationAdapter]:
-    parsed = AbiParserV0(abi).parse()
-
-    # Constructor might not accept any arguments
-    if not parsed.constructor or not parsed.constructor.inputs:
-        return None
-
-    return serializer_for_function(parsed.constructor)

coinex_api/ccxt/static_dependencies/starknet/utils/iterable.py

@@ -1,13 +0,0 @@
-from typing import Iterable, TypeVar, Union
-
-T = TypeVar("T")
-
-
-# pyright: reportGeneralTypeIssues=false
-def ensure_iterable(value: Union[T, Iterable[T]]) -> Iterable[T]:
-    try:
-        iter(value)
-        # Now we now it is iterable
-        return value
-    except TypeError:
-        return [value]

coinex_api/ccxt/static_dependencies/starknet/utils/schema.py

@@ -1,13 +0,0 @@
-import os
-
-from ..marshmallow import EXCLUDE, RAISE
-from ..marshmallow import Schema as MarshmallowSchema
-
-MARSHMALLOW_UKNOWN_EXCLUDE = os.environ.get("STARKNET_PY_MARSHMALLOW_UKNOWN_EXCLUDE")
-
-
-class Schema(MarshmallowSchema):
-    class Meta:
-        unknown = (
-            EXCLUDE if (MARSHMALLOW_UKNOWN_EXCLUDE or "").lower() == "true" else RAISE
-        )

coinex_api/ccxt/static_dependencies/starknet/utils/typed_data.py

@@ -1,182 +0,0 @@
-from dataclasses import dataclass
-from typing import Dict, List, Union, cast
-
-from ...marshmallow import Schema, fields, post_load
-
-from ..cairo.felt import encode_shortstring
-from ..hash.selector import get_selector_from_name
-from ..hash.utils import compute_hash_on_elements
-from ..models.typed_data import StarkNetDomainDict, TypedDataDict
-
-
-@dataclass(frozen=True)
-class Parameter:
-    """
-    Dataclass representing a Parameter object
-    """
-
-    name: str
-    type: str
-
-
-@dataclass(frozen=True)
-class TypedData:
-    """
-    Dataclass representing a TypedData object
-    """
-
-    types: Dict[str, List[Parameter]]
-    primary_type: str
-    domain: StarkNetDomainDict
-    message: dict
-
-    @staticmethod
-    def from_dict(data: TypedDataDict) -> "TypedData":
-        """
-        Create TypedData dataclass from dictionary.
-
-        :param data: TypedData dictionary.
-        :return: TypedData dataclass instance.
-        """
-        return cast(TypedData, TypedDataSchema().load(data))
-
-    def _is_struct(self, type_name: str) -> bool:
-        return type_name in self.types
-
-    def _encode_value(self, type_name: str, value: Union[int, str, dict, list]) -> int:
-        if is_pointer(type_name) and isinstance(value, list):
-            type_name = strip_pointer(type_name)
-
-            if self._is_struct(type_name):
-                return compute_hash_on_elements(
-                    [self.struct_hash(type_name, data) for data in value]
-                )
-            return compute_hash_on_elements([int(get_hex(val), 16) for val in value])
-
-        if self._is_struct(type_name) and isinstance(value, dict):
-            return self.struct_hash(type_name, value)
-
-        value = cast(Union[int, str], value)
-        return int(get_hex(value), 16)
-
-    def _encode_data(self, type_name: str, data: dict) -> List[int]:
-        values = []
-        for param in self.types[type_name]:
-            encoded_value = self._encode_value(param.type, data[param.name])
-            values.append(encoded_value)
-
-        return values
-
-    def _get_dependencies(self, type_name: str) -> List[str]:
-        if type_name not in self.types:
-            # type_name is a primitive type, has no dependencies
-            return []
-
-        dependencies = set()
-
-        def collect_deps(type_name: str) -> None:
-            for param in self.types[type_name]:
-                fixed_type = strip_pointer(param.type)
-                if fixed_type in self.types and fixed_type not in dependencies:
-                    dependencies.add(fixed_type)
-                    # recursive call
-                    collect_deps(fixed_type)
-
-        # collect dependencies into a set
-        collect_deps(type_name)
-        return [type_name, *list(dependencies)]
-
-    def _encode_type(self, type_name: str) -> str:
-        primary, *dependencies = self._get_dependencies(type_name)
-        types = [primary, *sorted(dependencies)]
-
-        def make_dependency_str(dependency):
-            lst = [f"{t.name}:{t.type}" for t in self.types[dependency]]
-            return f"{dependency}({','.join(lst)})"
-
-        return "".join([make_dependency_str(x) for x in types])
-
-    def type_hash(self, type_name: str) -> int:
-        """
-        Calculate the hash of a type name.
-
-        :param type_name: Name of the type.
-        :return: Hash of the type name.
-        """
-        return get_selector_from_name(self._encode_type(type_name))
-
-    def struct_hash(self, type_name: str, data: dict) -> int:
-        """
-        Calculate the hash of a struct.
-
-        :param type_name: Name of the type.
-        :param data: Data defining the struct.
-        :return: Hash of the struct.
-        """
-        return compute_hash_on_elements(
-            [self.type_hash(type_name), *self._encode_data(type_name, data)]
-        )
-
-    def message_hash(self, account_address: int) -> int:
-        """
-        Calculate the hash of the message.
-
-        :param account_address: Address of an account.
-        :return: Hash of the message.
-        """
-        message = [
-            encode_shortstring("StarkNet Message"),
-            self.struct_hash("StarkNetDomain", cast(dict, self.domain)),
-            account_address,
-            self.struct_hash(self.primary_type, self.message),
-        ]
-
-        return compute_hash_on_elements(message)
-
-
-def get_hex(value: Union[int, str]) -> str:
-    if isinstance(value, int):
-        return hex(value)
-    if value[:2] == "0x":
-        return value
-    if value.isnumeric():
-        return hex(int(value))
-    return hex(encode_shortstring(value))
-
-
-def is_pointer(value: str) -> bool:
-    return len(value) > 0 and value[-1] == "*"
-
-
-def strip_pointer(value: str) -> str:
-    if is_pointer(value):
-        return value[:-1]
-    return value
-
-
-# pylint: disable=unused-argument
-# pylint: disable=no-self-use
-
-
-class ParameterSchema(Schema):
-    name = fields.String(data_key="name", required=True)
-    type = fields.String(data_key="type", required=True)
-
-    @post_load
-    def make_dataclass(self, data, **kwargs) -> Parameter:
-        return Parameter(**data)
-
-
-class TypedDataSchema(Schema):
-    types = fields.Dict(
-        data_key="types",
-        keys=fields.Str(),
-        values=fields.List(fields.Nested(ParameterSchema())),
-    )
-    primary_type = fields.String(data_key="primaryType", required=True)
-    domain = fields.Dict(data_key="domain", required=True)
-    message = fields.Dict(data_key="message", required=True)
-
-    @post_load
-    def make_dataclass(self, data, **kwargs) -> TypedData:
-        return TypedData(**data)