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

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

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

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

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

ccxt/static_dependencies/starknet/serialization/errors.py

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

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([]),
+    )

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)

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)

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)

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]

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