coinex-api 0.0.15__py3-none-any.whl → 0.0.17__py3-none-any.whl

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

@@ -0,0 +1,229 @@
+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/ccxt/static_dependencies/starknet/serialization/function_serialization_adapter.py

@@ -0,0 +1,110 @@
+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/ccxt/static_dependencies/starknet/serialization/tuple_dataclass.py

@@ -0,0 +1,59 @@
+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/ccxt/static_dependencies/starknet/utils/constructor_args_translator.py

@@ -0,0 +1,86 @@
+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/ccxt/static_dependencies/starknet/utils/iterable.py

@@ -0,0 +1,13 @@
+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/ccxt/static_dependencies/starknet/utils/schema.py

@@ -0,0 +1,13 @@
+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/ccxt/static_dependencies/starknet/utils/typed_data.py

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