ccxt 4.2.77__py2.py3-none-any.whl → 4.4.49__py2.py3-none-any.whl

ccxt/static_dependencies/starknet/hash/compiled_class_hash_objects.py

@@ -0,0 +1,111 @@
+# File is copied from
+# https://github.com/starkware-libs/cairo-lang/blob/v0.13.1/src/starkware/starknet/core/os/contract_class/compiled_class_hash_objects.py
+
+import dataclasses
+import itertools
+from abc import ABC, abstractmethod
+from typing import Any, List, Union
+
+from poseidon_py.poseidon_hash import poseidon_hash_many
+
+
+class BytecodeSegmentStructure(ABC):
+    """
+    Represents the structure of the bytecode to allow loading it partially into the OS memory.
+    See the documentation of the OS function `bytecode_hash_node` in `compiled_class.cairo`
+    for more details.
+    """
+
+    @abstractmethod
+    def hash(self) -> int:
+        """
+        Computes the hash of the node.
+        """
+
+    def bytecode_with_skipped_segments(self):
+        """
+        Returns the bytecode of the node.
+        Skipped segments are replaced with [-1, -2, -2, -2, ...].
+        """
+        res: List[int] = []
+        self.add_bytecode_with_skipped_segments(res)
+        return res
+
+    @abstractmethod
+    def add_bytecode_with_skipped_segments(self, data: List[int]):
+        """
+        Same as bytecode_with_skipped_segments, but appends the result to the given list.
+        """
+
+
+@dataclasses.dataclass
+class BytecodeLeaf(BytecodeSegmentStructure):
+    """
+    Represents a leaf in the bytecode segment tree.
+    """
+
+    data: List[int]
+
+    def hash(self) -> int:
+        return poseidon_hash_many(self.data)
+
+    def add_bytecode_with_skipped_segments(self, data: List[int]):
+        data.extend(self.data)
+
+
+@dataclasses.dataclass
+class BytecodeSegmentedNode(BytecodeSegmentStructure):
+    """
+    Represents an internal node in the bytecode segment tree.
+    Each child can be loaded into memory or skipped.
+    """
+
+    segments: List["BytecodeSegment"]
+
+    def hash(self) -> int:
+        return (
+            poseidon_hash_many(
+                itertools.chain(  # pyright: ignore
+                    *[
+                        (node.segment_length, node.inner_structure.hash())
+                        for node in self.segments
+                    ]
+                )
+            )
+            + 1
+        )
+
+    def add_bytecode_with_skipped_segments(self, data: List[int]):
+        for segment in self.segments:
+            if segment.is_used:
+                segment.inner_structure.add_bytecode_with_skipped_segments(data)
+            else:
+                data.append(-1)
+                data.extend(-2 for _ in range(segment.segment_length - 1))
+
+
+@dataclasses.dataclass
+class BytecodeSegment:
+    """
+    Represents a child of BytecodeSegmentedNode.
+    """
+
+    # The length of the segment.
+    segment_length: int
+    # Should the segment (or part of it) be loaded to memory.
+    # In other words, is the segment used during the execution.
+    # Note that if is_used is False, the entire segment is not loaded to memory.
+    # If is_used is True, it is possible that part of the segment will be skipped (according
+    # to the "is_used" field of the child segments).
+    is_used: bool
+    # The inner structure of the segment.
+    inner_structure: BytecodeSegmentStructure
+
+    def __post_init__(self):
+        assert (
+            self.segment_length > 0
+        ), f"Invalid segment length: {self.segment_length}."
+
+
+# Represents a nested list of integers. E.g., [1, [2, [3], 4], 5, 6].
+NestedIntList = Union[int, List[Any]]

ccxt/static_dependencies/starknet/hash/selector.py

@@ -0,0 +1,16 @@
+from ..constants import (
+    DEFAULT_ENTRY_POINT_NAME,
+    DEFAULT_ENTRY_POINT_SELECTOR,
+    DEFAULT_L1_ENTRY_POINT_NAME,
+)
+from ..hash.utils import _starknet_keccak
+
+
+def get_selector_from_name(func_name: str) -> int:
+    """
+    Returns the selector of a contract's function name.
+    """
+    if func_name in [DEFAULT_ENTRY_POINT_NAME, DEFAULT_L1_ENTRY_POINT_NAME]:
+        return DEFAULT_ENTRY_POINT_SELECTOR
+
+    return _starknet_keccak(data=func_name.encode("ascii"))

ccxt/static_dependencies/starknet/hash/storage.py

@@ -0,0 +1,12 @@
+from functools import reduce
+
+from constants import ADDR_BOUND
+from hash.utils import _starknet_keccak, pedersen_hash
+
+
+def get_storage_var_address(var_name: str, *args: int) -> int:
+    """
+    Returns the storage address of a Starknet storage variable given its name and arguments.
+    """
+    res = _starknet_keccak(var_name.encode("ascii"))
+    return reduce(pedersen_hash, args, res) % ADDR_BOUND

ccxt/static_dependencies/starknet/hash/utils.py

@@ -0,0 +1,78 @@
+import functools
+from typing import List, Optional, Sequence
+
+from ... import keccak
+
+from ..common import int_from_bytes
+from ..constants import EC_ORDER
+from ...starkware.crypto.signature import (
+    ECSignature,
+    private_to_stark_key,
+    sign
+    # verify
+)
+from ...starkware.crypto.fast_pedersen_hash import (
+    pedersen_hash
+)
+
+MASK_250 = 2**250 - 1
+HEX_PREFIX = "0x"
+
+
+def _starknet_keccak(data: bytes) -> int:
+    """
+    A variant of eth-keccak that computes a value that fits in a Starknet field element.
+    """
+    return int_from_bytes(keccak.SHA3(data)) & MASK_250
+
+
+# def pedersen_hash(left: int, right: int) -> int:
+#     """
+#     One of two hash functions (along with _starknet_keccak) used throughout Starknet.
+#     """
+#     return cpp_hash(left, right)
+
+
+def compute_hash_on_elements(data: Sequence) -> int:
+    """
+    Computes a hash chain over the data, in the following order:
+        h(h(h(h(0, data[0]), data[1]), ...), data[n-1]), n).
+
+    The hash is initialized with 0 and ends with the data length appended.
+    The length is appended in order to avoid collisions of the following kind:
+    H([x,y,z]) = h(h(x,y),z) = H([w, z]) where w = h(x,y).
+    """
+    return functools.reduce(pedersen_hash, [*data, len(data)], 0)
+
+
+def message_signature(
+    msg_hash: int, priv_key: int, seed: Optional[int] = 32
+) -> ECSignature:
+    """
+    Signs the message with private key.
+    """
+    return sign(msg_hash, priv_key, seed)
+
+
+# def verify_message_signature(
+#     msg_hash: int, signature: List[int], public_key: int
+# ) -> bool:
+#     """
+#     Verifies ECDSA signature of a given message hash with a given public key.
+#     Returns true if public_key signs the message.
+#     """
+#     sig_r, sig_s = signature
+#     # sig_w = pow(sig_s, -1, EC_ORDER)
+#     return verify(msg_hash=msg_hash, r=sig_r, s=sig_s, public_key=public_key)
+
+
+def encode_uint(value: int, bytes_length: int = 32) -> bytes:
+    return value.to_bytes(bytes_length, byteorder="big")
+
+
+def encode_uint_list(data: List[int]) -> bytes:
+    return b"".join(encode_uint(x) for x in data)
+
+
+def get_bytes_length(value: int) -> int:
+    return (value.bit_length() + 7) // 8

ccxt/static_dependencies/starknet/models/typed_data.py

@@ -0,0 +1,45 @@
+"""
+TypedDict structures for TypedData
+"""
+
+from enum import Enum
+from typing import Any, Dict, List, Optional, TypedDict
+
+class Revision(Enum):
+    """
+    Enum representing the revision of the specification to be used.
+    """
+
+    V0 = 0
+    V1 = 1
+
+
+class ParameterDict(TypedDict):
+    """
+    TypedDict representing a Parameter object
+    """
+
+    name: str
+    type: str
+
+
+class StarkNetDomainDict(TypedDict):
+    """
+    TypedDict representing a domain object (both StarkNetDomain, StarknetDomain).
+    """
+
+    name: str
+    version: str
+    chainId: str
+    revision: Optional[Revision]
+
+
+class TypedDataDict(TypedDict):
+    """
+    TypedDict representing a TypedData object
+    """
+
+    types: Dict[str, List[ParameterDict]]
+    primaryType: str
+    domain: StarkNetDomainDict
+    message: Dict[str, Any]

ccxt/static_dependencies/starknet/serialization/__init__.py

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

ccxt/static_dependencies/starknet/serialization/_calldata_reader.py

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

ccxt/static_dependencies/starknet/serialization/_context.py

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

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

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

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

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

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

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

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

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