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

ccxt/static_dependencies/starknet/cairo/deprecated_parse/parser.py

@@ -0,0 +1,46 @@
+from ....lark import Lark
+
+from .cairo_types import CairoType
+from .parser_transformer import ParserTransformer
+
+CAIRO_EBNF = """
+    %import common.WS_INLINE
+    %ignore WS_INLINE
+
+    IDENTIFIER: /[a-zA-Z_][a-zA-Z_0-9]*/
+    _DBL_STAR: "**"
+    COMMA: ","
+
+    ?type: non_identifier_type
+        | identifier             -> type_struct
+
+    comma_separated{item}: item? (COMMA item)* COMMA?
+
+    named_type: identifier (":" type)? | non_identifier_type
+    non_identifier_type: "felt"                                         -> type_felt
+                    | "codeoffset"                                   -> type_codeoffset
+                    | type "*"                                       -> type_pointer
+                    | type _DBL_STAR                                 -> type_pointer2
+                    | "(" comma_separated{named_type} ")" -> type_tuple
+
+    identifier: IDENTIFIER ("." IDENTIFIER)*
+"""
+
+
+def parse(code: str) -> CairoType:
+    """
+    Parses the given string and returns a CairoType.
+    """
+
+    grammar = CAIRO_EBNF
+
+    grammar_parser = Lark(
+        grammar=grammar,
+        start=["type"],
+        parser="lalr",
+    )
+
+    parsed = grammar_parser.parse(code)
+    transformed = ParserTransformer().transform(parsed)
+
+    return transformed

ccxt/static_dependencies/starknet/cairo/deprecated_parse/parser_transformer.py

@@ -0,0 +1,138 @@
+import dataclasses
+from typing import Optional, Tuple
+
+from ....lark import Token, Transformer, v_args
+
+from .cairo_types import (
+    CairoType,
+    ExprIdentifier,
+    TypeCodeoffset,
+    TypeFelt,
+    TypeIdentifier,
+    TypePointer,
+    TypeStruct,
+    TypeTuple,
+)
+
+
+@dataclasses.dataclass
+class ParserContext:
+    """
+    Represents information that affects the parsing process.
+    """
+
+    # If True, treat type identifiers as resolved.
+    resolved_types: bool = False
+
+
+class ParserError(Exception):
+    """
+    Base exception for parsing process.
+    """
+
+
+@dataclasses.dataclass
+class CommaSeparated:
+    """
+    Represents a list of comma separated values, such as expressions or types.
+    """
+
+    args: list
+    has_trailing_comma: bool
+
+
+class ParserTransformer(Transformer):
+    """
+    Transforms the lark tree into an AST based on the classes defined in cairo_types.py.
+    """
+
+    # pylint: disable=unused-argument, no-self-use
+
+    def __init__(self):
+        super().__init__()
+        self.parser_context = ParserContext()
+
+    def __default__(self, data: str, children, meta):
+        raise TypeError(f"Unable to parse tree node of type {data}")
+
+    def comma_separated(self, value) -> CommaSeparated:
+        saw_comma = None
+        args: list = []
+        for v in value:
+            if isinstance(v, Token) and v.type == "COMMA":
+                if saw_comma is not False:
+                    raise ParserError("Unexpected comma.")
+                saw_comma = True
+            else:
+                if saw_comma is False:
+                    raise ParserError("Expected a comma before this expression.")
+                args.append(v)
+
+                # Reset state.
+                saw_comma = False
+
+        if saw_comma is None:
+            saw_comma = False
+
+        return CommaSeparated(args=args, has_trailing_comma=saw_comma)
+
+    # Types.
+
+    @v_args(meta=True)
+    def named_type(self, meta, value) -> TypeTuple.Item:
+        name: Optional[str]
+        if len(value) == 1:
+            # Unnamed type.
+            (typ,) = value
+            name = None
+            if isinstance(typ, ExprIdentifier):
+                typ = self.type_struct([typ])
+        elif len(value) == 2:
+            # Named type.
+            identifier, typ = value
+            assert isinstance(identifier, ExprIdentifier)
+            assert isinstance(typ, CairoType)
+            if "." in identifier.name:
+                raise ParserError("Unexpected . in name.")
+            name = identifier.name
+        else:
+            raise NotImplementedError(f"Unexpected number of values. {value}")
+
+        return TypeTuple.Item(name=name, typ=typ)
+
+    @v_args(meta=True)
+    def type_felt(self, meta, value):
+        return TypeFelt()
+
+    @v_args(meta=True)
+    def type_codeoffset(self, meta, value):
+        return TypeCodeoffset()
+
+    def type_struct(self, value):
+        assert len(value) == 1 and isinstance(value[0], ExprIdentifier)
+        if self.parser_context.resolved_types:
+            # If parser_context.resolved_types is True, assume that the type is a struct.
+            return TypeStruct(scope=value[0].name)
+
+        return TypeIdentifier(name=value[0].name)
+
+    @v_args(meta=True)
+    def type_pointer(self, meta, value):
+        return TypePointer(pointee=value[0])
+
+    @v_args(meta=True)
+    def type_pointer2(self, meta, value):
+        return TypePointer(pointee=TypePointer(pointee=value[0]))
+
+    @v_args(meta=True)
+    def type_tuple(self, meta, value: Tuple[CommaSeparated]):
+        (lst,) = value
+        return TypeTuple(members=lst.args, has_trailing_comma=lst.has_trailing_comma)
+
+    @v_args(meta=True)
+    def identifier(self, meta, value):
+        return ExprIdentifier(name=".".join(x.value for x in value))
+
+    @v_args(meta=True)
+    def identifier_def(self, meta, value):
+        return ExprIdentifier(name=value[0].value)

ccxt/static_dependencies/starknet/cairo/felt.py

@@ -0,0 +1,64 @@
+from typing import List
+
+from ..constants import FIELD_PRIME
+
+CairoData = List[int]
+
+
+MAX_UINT256 = (1 << 256) - 1
+MIN_UINT256 = 0
+
+
+def uint256_range_check(value: int):
+    if not MIN_UINT256 <= value <= MAX_UINT256:
+        raise ValueError(
+            f"Uint256 is expected to be in range [0;2**256), got: {value}."
+        )
+
+
+MIN_FELT = -FIELD_PRIME // 2
+MAX_FELT = FIELD_PRIME // 2
+
+
+def is_in_felt_range(value: int) -> bool:
+    return 0 <= value < FIELD_PRIME
+
+
+def cairo_vm_range_check(value: int):
+    if not is_in_felt_range(value):
+        raise ValueError(
+            f"Felt is expected to be in range [0; {FIELD_PRIME}), got: {value}."
+        )
+
+
+def encode_shortstring(text: str) -> int:
+    """
+    A function which encodes short string value (at most 31 characters) into cairo felt (MSB as first character)
+
+    :param text: A short string value in python
+    :return: Short string value encoded into felt
+    """
+    if len(text) > 31:
+        raise ValueError(
+            f"Shortstring cannot be longer than 31 characters, got: {len(text)}."
+        )
+
+    try:
+        text_bytes = text.encode("ascii")
+    except UnicodeEncodeError as u_err:
+        raise ValueError(f"Expected an ascii string. Found: {repr(text)}.") from u_err
+    value = int.from_bytes(text_bytes, "big")
+
+    cairo_vm_range_check(value)
+    return value
+
+
+def decode_shortstring(value: int) -> str:
+    """
+    A function which decodes a felt value to short string (at most 31 characters)
+
+    :param value: A felt value
+    :return: Decoded string which is corresponds to that felt
+    """
+    cairo_vm_range_check(value)
+    return "".join([chr(i) for i in value.to_bytes(31, byteorder="big")]).lstrip("\x00")

ccxt/static_dependencies/starknet/cairo/type_parser.py

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

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

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

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

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

ccxt/static_dependencies/starknet/ccxt_utils.py

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

ccxt/static_dependencies/starknet/common.py

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

ccxt/static_dependencies/starknet/constants.py

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

ccxt/static_dependencies/starknet/hash/address.py

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