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

coinex/ccxt/static_dependencies/starknet/cairo/type_parser.py

@@ -1,121 +0,0 @@
-from __future__ import annotations
-
-from collections import OrderedDict
-from typing import Dict, cast
-
-from .deprecated_parse import cairo_types as cairo_lang_types
-from .data_types import (
-    ArrayType,
-    CairoType,
-    FeltType,
-    NamedTupleType,
-    StructType,
-    TupleType,
-)
-from .deprecated_parse.parser import parse
-
-
-class UnknownCairoTypeError(ValueError):
-    """
-    Error thrown when TypeParser finds type that was not declared prior to parsing.
-    """
-
-    type_name: str
-
-    def __init__(self, type_name: str):
-        super().__init__(f"Type '{type_name}' is not defined")
-        self.type_name = type_name
-
-
-class TypeParser:
-    """
-    Low level utility class for parsing Cairo types that can be used in external methods.
-    """
-
-    defined_types: Dict[str, StructType]
-
-    def __init__(self, defined_types: Dict[str, StructType]):
-        """
-        TypeParser constructor.
-
-        :param defined_types: dictionary containing all defined types. For now, they can only be structures.
-        """
-        self.defined_types = defined_types
-        for name, struct in defined_types.items():
-            if name != struct.name:
-                raise ValueError(
-                    f"Keys must match name of type, '{name}' != '{struct.name}'."
-                )
-
-    def parse_inline_type(self, type_string: str) -> CairoType:
-        """
-        Inline type is one that can be used inline, for instance as return type. For instance
-        (a: Uint256, b: felt*, c: (felt, felt)). Structure can only be referenced in inline type, can't be defined
-        this way.
-
-        :param type_string: type to parse.
-        """
-        parsed = parse(type_string)
-        return self._transform_cairo_lang_type(parsed)
-
-    def _transform_cairo_lang_type(
-        self, cairo_type: cairo_lang_types.CairoType
-    ) -> CairoType:
-        """
-        For now, we use parse function from cairo-lang package. It will be replaced in the future, but we need to hide
-        it from the users.
-        This function takes types returned by cairo-lang package and maps them to our type classes.
-
-        :param cairo_type: type returned from parse_type function.
-        :return: CairoType defined by our package.
-        """
-        if isinstance(cairo_type, cairo_lang_types.TypeFelt):
-            return FeltType()
-
-        if isinstance(cairo_type, cairo_lang_types.TypePointer):
-            return ArrayType(self._transform_cairo_lang_type(cairo_type.pointee))
-
-        if isinstance(cairo_type, cairo_lang_types.TypeIdentifier):
-            return self._get_struct(str(cairo_type.name))
-
-        if isinstance(cairo_type, cairo_lang_types.TypeTuple):
-            # Cairo returns is_named when there are no members
-            if cairo_type.is_named and len(cairo_type.members) != 0:
-                assert all(member.name is not None for member in cairo_type.members)
-
-                return NamedTupleType(
-                    OrderedDict(
-                        (
-                            cast(
-                                str, member.name
-                            ),  # without that pyright is complaining
-                            self._transform_cairo_lang_type(member.typ),
-                        )
-                        for member in cairo_type.members
-                    )
-                )
-
-            return TupleType(
-                [
-                    self._transform_cairo_lang_type(member.typ)
-                    for member in cairo_type.members
-                ]
-            )
-
-        # Contracts don't support codeoffset as input/output type, user can only use it if it was defined in types
-        if isinstance(cairo_type, cairo_lang_types.TypeCodeoffset):
-            return self._get_struct("codeoffset")
-
-        # Other options are: TypeFunction, TypeStruct
-        # Neither of them are possible. In particular TypeStruct is not possible because we parse structs without
-        # info about other structs, so they will be just TypeIdentifier (structure that was not parsed).
-
-        # This is an error of our logic, so we throw a RuntimeError.
-        raise RuntimeError(
-            f"Received unknown type '{cairo_type}' from parser."
-        )  # pragma: no cover
-
-    def _get_struct(self, name: str):
-        if name not in self.defined_types:
-            raise UnknownCairoTypeError(name)
-        return self.defined_types[name]

coinex/ccxt/static_dependencies/starknet/cairo/v1/type_parser.py

@@ -1,59 +0,0 @@
-from __future__ import annotations
-
-from typing import Dict, Union
-
-from ...abi.v1.parser_transformer import parse
-from ..data_types import CairoType, EnumType, StructType, TypeIdentifier
-
-
-class UnknownCairoTypeError(ValueError):
-    """
-    Error thrown when TypeParser finds type that was not declared prior to parsing.
-    """
-
-    type_name: str
-
-    def __init__(self, type_name: str):
-        super().__init__(
-            # pylint: disable=line-too-long
-            f"Type '{type_name}' is not defined. Please report this issue at https://github.com/software-mansion/starknet.py/issues"
-        )
-        self.type_name = type_name
-
-
-class TypeParser:
-    """
-    Low level utility class for parsing Cairo types that can be used in external methods.
-    """
-
-    defined_types: Dict[str, Union[StructType, EnumType]]
-
-    def __init__(self, defined_types: Dict[str, Union[StructType, EnumType]]):
-        """
-        TypeParser constructor.
-
-        :param defined_types: dictionary containing all defined types. For now, they can only be structures.
-        """
-        self.defined_types = defined_types
-        for name, defined_type in defined_types.items():
-            if name != defined_type.name:
-                raise ValueError(
-                    f"Keys must match name of type, '{name}' != '{defined_type.name}'."
-                )
-
-    def parse_inline_type(self, type_string: str) -> CairoType:
-        """
-        Inline type is one that can be used inline, for instance as return type. For instance
-        (core::felt252, (), (core::felt252,)). Structure can only be referenced in inline type, can't be defined
-        this way.
-
-        :param type_string: type to parse.
-        """
-        parsed = parse(type_string, self.defined_types)
-        if isinstance(parsed, TypeIdentifier):
-            for defined_name in self.defined_types.keys():
-                if parsed.name == defined_name.split("<")[0].strip(":"):
-                    return self.defined_types[defined_name]
-            raise UnknownCairoTypeError(parsed.name)
-
-        return parsed

coinex/ccxt/static_dependencies/starknet/cairo/v2/type_parser.py

@@ -1,77 +0,0 @@
-from __future__ import annotations
-
-from typing import Dict, Union
-
-from ...abi.v2.parser_transformer import parse
-from ..data_types import (
-    CairoType,
-    EnumType,
-    EventType,
-    StructType,
-    TypeIdentifier,
-)
-
-
-class UnknownCairoTypeError(ValueError):
-    """
-    Error thrown when TypeParser finds type that was not declared prior to parsing.
-    """
-
-    type_name: str
-
-    def __init__(self, type_name: str):
-        super().__init__(
-            # pylint: disable=line-too-long
-            f"Type '{type_name}' is not defined. Please report this issue at https://github.com/software-mansion/starknet.py/issues"
-        )
-        self.type_name = type_name
-
-
-class TypeParser:
-    """
-    Low level utility class for parsing Cairo types that can be used in external methods.
-    """
-
-    defined_types: Dict[str, Union[StructType, EnumType, EventType]]
-
-    def __init__(
-        self, defined_types: Dict[str, Union[StructType, EnumType, EventType]]
-    ):
-        """
-        TypeParser constructor.
-
-        :param defined_types: dictionary containing all defined types. For now, they can only be structures.
-        """
-        self.defined_types = defined_types
-        for name, defined_type in defined_types.items():
-            if name != defined_type.name:
-                raise ValueError(
-                    f"Keys must match name of type, '{name}' != '{defined_type.name}'."
-                )
-
-    def update_defined_types(
-        self, defined_types: Dict[str, Union[StructType, EnumType, EventType]]
-    ) -> None:
-        self.defined_types.update(defined_types)
-
-    def add_defined_type(
-        self, defined_type: Union[StructType, EnumType, EventType]
-    ) -> None:
-        self.defined_types.update({defined_type.name: defined_type})
-
-    def parse_inline_type(self, type_string: str) -> CairoType:
-        """
-        Inline type is one that can be used inline, for instance as return type. For instance
-        (core::felt252, (), (core::felt252,)). Structure can only be referenced in inline type, can't be defined
-        this way.
-
-        :param type_string: type to parse.
-        """
-        parsed = parse(type_string, self.defined_types)
-        if isinstance(parsed, TypeIdentifier):
-            for defined_name in self.defined_types.keys():
-                if parsed.name == defined_name.split("<")[0].strip(":"):
-                    return self.defined_types[defined_name]
-            raise UnknownCairoTypeError(parsed.name)
-
-        return parsed

coinex/ccxt/static_dependencies/starknet/ccxt_utils.py

@@ -1,7 +0,0 @@
-# utils to use starknet library in ccxt
-from .constants import EC_ORDER
-from ..starkware.crypto.signature import grind_key
-
-def get_private_key_from_eth_signature(eth_signature_hex: str) -> int:
-    r = eth_signature_hex[2 : 64 + 2] if eth_signature_hex[0:2] == '0x' else eth_signature_hex[0 : 64]
-    return grind_key(int(r, 16), EC_ORDER)

coinex/ccxt/static_dependencies/starknet/common.py

@@ -1,15 +0,0 @@
-from typing import Literal, Union
-
-def int_from_hex(number: Union[str, int]) -> int:
-    return number if isinstance(number, int) else int(number, 16)
-
-
-def int_from_bytes(
-    value: bytes,
-    byte_order: Literal["big", "little"] = "big",
-    signed: bool = False,
-) -> int:
-    """
-    Converts the given bytes object (parsed according to the given byte order) to an integer.
-    """
-    return int.from_bytes(value, byteorder=byte_order, signed=signed)

coinex/ccxt/static_dependencies/starknet/constants.py

@@ -1,39 +0,0 @@
-from pathlib import Path
-
-# Address came from starkware-libs/starknet-addresses repository: https://github.com/starkware-libs/starknet-addresses
-FEE_CONTRACT_ADDRESS = (
-    "0x049d36570d4e46f48e99674bd3fcc84644ddd6b96f7c741b1562b82f9e004dc7"
-)
-
-DEFAULT_DEPLOYER_ADDRESS = (
-    "0x041a78e741e5aF2fEc34B695679bC6891742439f7AFB8484Ecd7766661aD02BF"
-)
-
-API_VERSION = 0
-
-RPC_CONTRACT_NOT_FOUND_ERROR = 20
-RPC_INVALID_MESSAGE_SELECTOR_ERROR = 21
-RPC_CLASS_HASH_NOT_FOUND_ERROR = 28
-RPC_CONTRACT_ERROR = 40
-
-DEFAULT_ENTRY_POINT_NAME = "__default__"
-DEFAULT_L1_ENTRY_POINT_NAME = "__l1_default__"
-DEFAULT_ENTRY_POINT_SELECTOR = 0
-DEFAULT_DECLARE_SENDER_ADDRESS = 1
-
-# MAX_STORAGE_ITEM_SIZE and ADDR_BOUND must be consistent with the corresponding constant in
-# starkware/starknet/common/storage.cairo.
-MAX_STORAGE_ITEM_SIZE = 256
-ADDR_BOUND = 2**251 - MAX_STORAGE_ITEM_SIZE
-
-FIELD_PRIME = 0x800000000000011000000000000000000000000000000000000000000000001
-EC_ORDER = 0x800000000000010FFFFFFFFFFFFFFFFB781126DCAE7B2321E66A241ADC64D2F
-
-# From cairo-lang
-# int_from_bytes(b"STARKNET_CONTRACT_ADDRESS")
-CONTRACT_ADDRESS_PREFIX = 523065374597054866729014270389667305596563390979550329787219
-L2_ADDRESS_UPPER_BOUND = 2**251 - 256
-
-QUERY_VERSION_BASE = 2**128
-
-ROOT_PATH = Path(__file__).parent

coinex/ccxt/static_dependencies/starknet/hash/address.py

@@ -1,79 +0,0 @@
-from typing import Sequence
-
-from ..constants import CONTRACT_ADDRESS_PREFIX, L2_ADDRESS_UPPER_BOUND
-from .utils import (
-    HEX_PREFIX,
-    _starknet_keccak,
-    compute_hash_on_elements,
-    encode_uint,
-    get_bytes_length,
-)
-
-
-def compute_address(
-    *,
-    class_hash: int,
-    constructor_calldata: Sequence[int],
-    salt: int,
-    deployer_address: int = 0,
-) -> int:
-    """
-    Computes the contract address in the Starknet network - a unique identifier of the contract.
-
-    :param class_hash: class hash of the contract
-    :param constructor_calldata: calldata for the contract constructor
-    :param salt: salt used to calculate contract address
-    :param deployer_address: address of the deployer (if not provided default 0 is used)
-    :return: Contract's address
-    """
-
-    constructor_calldata_hash = compute_hash_on_elements(data=constructor_calldata)
-    raw_address = compute_hash_on_elements(
-        data=[
-            CONTRACT_ADDRESS_PREFIX,
-            deployer_address,
-            salt,
-            class_hash,
-            constructor_calldata_hash,
-        ],
-    )
-
-    return raw_address % L2_ADDRESS_UPPER_BOUND
-
-
-def get_checksum_address(address: str) -> str:
-    """
-    Outputs formatted checksum address.
-
-    Follows implementation of starknet.js. It is not compatible with EIP55 as it treats hex string as encoded number,
-    instead of encoding it as ASCII string.
-
-    :param address: Address to encode
-    :return: Checksum address
-    """
-    if not address.lower().startswith(HEX_PREFIX):
-        raise ValueError(f"{address} is not a valid hexadecimal address.")
-
-    int_address = int(address, 16)
-    string_address = address[2:].zfill(64)
-
-    address_in_bytes = encode_uint(int_address, get_bytes_length(int_address))
-    address_hash = _starknet_keccak(address_in_bytes)
-
-    result = "".join(
-        (
-            char.upper()
-            if char.isalpha() and (address_hash >> 256 - 4 * i - 1) & 1
-            else char
-        )
-        for i, char in enumerate(string_address)
-    )
-
-    return f"{HEX_PREFIX}{result}"
-
-
-def is_checksum_address(address: str) -> bool:
-    """
-    Checks if provided string is in a checksum address format.
-    """
-    return get_checksum_address(address) == address

coinex/ccxt/static_dependencies/starknet/hash/compiled_class_hash_objects.py

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

coinex/ccxt/static_dependencies/starknet/hash/selector.py

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

coinex/ccxt/static_dependencies/starknet/hash/storage.py

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

coinex/ccxt/static_dependencies/starknet/hash/utils.py

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

coinex/ccxt/static_dependencies/starknet/models/typed_data.py

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