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

coinex/ccxt/static_dependencies/starknet/abi/v2/schemas.py

@@ -0,0 +1,132 @@
+from ....marshmallow import Schema, fields
+from ....marshmallow_oneofschema import OneOfSchema
+
+from .shape import (
+    CONSTRUCTOR_ENTRY,
+    DATA_KIND,
+    ENUM_ENTRY,
+    EVENT_ENTRY,
+    FUNCTION_ENTRY,
+    IMPL_ENTRY,
+    INTERFACE_ENTRY,
+    L1_HANDLER_ENTRY,
+    NESTED_KIND,
+    STRUCT_ENTRY,
+)
+
+
+class TypeSchema(Schema):
+    type = fields.String(data_key="type", required=True)
+
+
+class TypedParameterSchema(TypeSchema):
+    name = fields.String(data_key="name", required=True)
+
+
+class FunctionBaseSchema(Schema):
+    name = fields.String(data_key="name", required=True)
+    inputs = fields.List(
+        fields.Nested(TypedParameterSchema()), data_key="inputs", required=True
+    )
+    outputs = fields.List(
+        fields.Nested(TypeSchema()), data_key="outputs", required=True
+    )
+    state_mutability = fields.String(data_key="state_mutability", default=None)
+
+
+class FunctionAbiEntrySchema(FunctionBaseSchema):
+    type = fields.Constant(FUNCTION_ENTRY, data_key="type", required=True)
+
+
+class ConstructorAbiEntrySchema(Schema):
+    type = fields.Constant(CONSTRUCTOR_ENTRY, data_key="type", required=True)
+    name = fields.String(data_key="name", required=True)
+    inputs = fields.List(
+        fields.Nested(TypedParameterSchema()), data_key="inputs", required=True
+    )
+
+
+class L1HandlerAbiEntrySchema(FunctionBaseSchema):
+    type = fields.Constant(L1_HANDLER_ENTRY, data_key="type", required=True)
+
+
+class EventStructMemberSchema(TypedParameterSchema):
+    kind = fields.Constant(DATA_KIND, data_key="kind", required=True)
+
+
+class EventStructAbiEntrySchema(Schema):
+    type = fields.Constant(EVENT_ENTRY, data_key="type", required=True)
+    name = fields.String(data_key="name", required=True)
+    kind = fields.Constant(STRUCT_ENTRY, data_key="kind", required=True)
+    members = fields.List(
+        fields.Nested(EventStructMemberSchema()), data_key="members", required=True
+    )
+
+
+class EventEnumVariantSchema(TypedParameterSchema):
+    kind = fields.Constant(NESTED_KIND, data_key="kind", required=True)
+
+
+class EventEnumAbiEntrySchema(Schema):
+    type = fields.Constant(EVENT_ENTRY, data_key="type", required=True)
+    name = fields.String(data_key="name", required=True)
+    kind = fields.Constant(ENUM_ENTRY, data_key="kind", required=True)
+    variants = fields.List(
+        fields.Nested(EventEnumVariantSchema()), data_key="variants", required=True
+    )
+
+
+class EventAbiEntrySchema(OneOfSchema):
+    type_field = "kind"
+    type_field_remove = False
+    type_schemas = {
+        STRUCT_ENTRY: EventStructAbiEntrySchema,
+        ENUM_ENTRY: EventEnumAbiEntrySchema,
+    }
+
+
+class StructAbiEntrySchema(Schema):
+    type = fields.Constant(STRUCT_ENTRY, data_key="type", required=True)
+    name = fields.String(data_key="name", required=True)
+    members = fields.List(
+        fields.Nested(TypedParameterSchema()), data_key="members", required=True
+    )
+
+
+class EnumAbiEntrySchema(Schema):
+    type = fields.Constant(ENUM_ENTRY, data_key="type", required=True)
+    name = fields.String(data_key="name", required=True)
+    variants = fields.List(
+        fields.Nested(TypedParameterSchema(), data_key="variants", required=True)
+    )
+
+
+class ImplAbiEntrySchema(Schema):
+    type = fields.Constant(IMPL_ENTRY, data_key="type", required=True)
+    name = fields.String(data_key="name", required=True)
+    interface_name = fields.String(data_key="interface_name", required=True)
+
+
+class InterfaceAbiEntrySchema(Schema):
+    type = fields.Constant(INTERFACE_ENTRY, data_key="type", required=True)
+    name = fields.String(data_key="name", required=True)
+
+    items = fields.List(
+        fields.Nested(
+            FunctionAbiEntrySchema(), data_key="items", required=True
+        )  # for now only functions can be defined here
+    )
+
+
+class ContractAbiEntrySchema(OneOfSchema):
+    type_field_remove = False
+    type_schemas = {
+        FUNCTION_ENTRY: FunctionAbiEntrySchema,
+        EVENT_ENTRY: EventAbiEntrySchema,
+        STRUCT_ENTRY: StructAbiEntrySchema,
+        ENUM_ENTRY: EnumAbiEntrySchema,
+        CONSTRUCTOR_ENTRY: ConstructorAbiEntrySchema,
+        L1_HANDLER_ENTRY: L1HandlerAbiEntrySchema,
+        IMPL_ENTRY: ImplAbiEntrySchema,
+        INTERFACE_ENTRY: InterfaceAbiEntrySchema,
+    }

coinex/ccxt/static_dependencies/starknet/abi/v2/shape.py

@@ -0,0 +1,107 @@
+from __future__ import annotations
+
+from typing import List, Literal, Optional, TypedDict, Union
+
+STRUCT_ENTRY = "struct"
+EVENT_ENTRY = "event"
+FUNCTION_ENTRY = "function"
+ENUM_ENTRY = "enum"
+CONSTRUCTOR_ENTRY = "constructor"
+L1_HANDLER_ENTRY = "l1_handler"
+IMPL_ENTRY = "impl"
+INTERFACE_ENTRY = "interface"
+
+DATA_KIND = "data"
+NESTED_KIND = "nested"
+
+
+class TypeDict(TypedDict):
+    type: str
+
+
+class TypedParameterDict(TypeDict):
+    name: str
+
+
+class StructDict(TypedDict):
+    type: Literal["struct"]
+    name: str
+    members: List[TypedParameterDict]
+
+
+class FunctionBaseDict(TypedDict):
+    name: str
+    inputs: List[TypedParameterDict]
+    outputs: List[TypeDict]
+    state_mutability: Optional[Literal["external", "view"]]
+
+
+class FunctionDict(FunctionBaseDict):
+    type: Literal["function"]
+
+
+class ConstructorDict(TypedDict):
+    type: Literal["constructor"]
+    name: str
+    inputs: List[TypedParameterDict]
+
+
+class L1HandlerDict(FunctionBaseDict):
+    type: Literal["l1_handler"]
+
+
+class EventBaseDict(TypedDict):
+    type: Literal["event"]
+    name: str
+
+
+class EventStructMemberDict(TypedParameterDict):
+    kind: Literal["data"]
+
+
+class EventStructDict(EventBaseDict):
+    kind: Literal["struct"]
+    members: List[EventStructMemberDict]
+
+
+class EventEnumVariantDict(TypedParameterDict):
+    kind: Literal["nested"]
+
+
+class EventEnumDict(EventBaseDict):
+    kind: Literal["enum"]
+    variants: List[EventEnumVariantDict]
+
+
+EventDict = Union[EventStructDict, EventEnumDict]
+
+
+class EnumDict(TypedDict):
+    type: Literal["enum"]
+    name: str
+    variants: List[TypedParameterDict]
+
+
+class ImplDict(TypedDict):
+    type: Literal["impl"]
+    name: str
+    interface_name: str
+
+
+class InterfaceDict(TypedDict):
+    type: Literal["interface"]
+    name: str
+    items: List[FunctionDict]  # for now only functions can be defined here
+
+
+AbiDictEntry = Union[
+    StructDict,
+    FunctionDict,
+    EventDict,
+    EnumDict,
+    ConstructorDict,
+    L1HandlerDict,
+    ImplDict,
+    InterfaceDict,
+]
+AbiDictList = List[AbiDictEntry]

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

@@ -0,0 +1,123 @@
+from __future__ import annotations
+
+from abc import ABC
+from collections import OrderedDict
+from dataclasses import dataclass
+from typing import List
+
+
+class CairoType(ABC):
+    """
+    Base type for all Cairo type representations. All types extend it.
+    """
+
+
+@dataclass
+class FeltType(CairoType):
+    """
+    Type representation of Cairo field element.
+    """
+
+
+@dataclass
+class BoolType(CairoType):
+    """
+    Type representation of Cairo boolean.
+    """
+
+
+@dataclass
+class TupleType(CairoType):
+    """
+    Type representation of Cairo tuples without named fields.
+    """
+
+    types: List[CairoType]  #: types of every tuple element.
+
+
+@dataclass
+class NamedTupleType(CairoType):
+    """
+    Type representation of Cairo tuples with named fields.
+    """
+
+    types: OrderedDict[str, CairoType]  #: types of every tuple member.
+
+
+@dataclass
+class ArrayType(CairoType):
+    """
+    Type representation of Cairo arrays.
+    """
+
+    inner_type: CairoType  #: type of element inside array.
+
+
+@dataclass
+class StructType(CairoType):
+    """
+    Type representation of Cairo structures.
+    """
+
+    name: str  #: Structure name
+    # We need ordered dict, because it is important in serialization
+    types: OrderedDict[str, CairoType]  #: types of every structure member.
+
+
+@dataclass
+class EnumType(CairoType):
+    """
+    Type representation of Cairo enums.
+    """
+
+    name: str
+    variants: OrderedDict[str, CairoType]
+
+
+@dataclass
+class OptionType(CairoType):
+    """
+    Type representation of Cairo options.
+    """
+
+    type: CairoType
+
+
+@dataclass
+class UintType(CairoType):
+    """
+    Type representation of Cairo unsigned integers.
+    """
+
+    bits: int
+
+    def check_range(self, value: int):
+        """
+        Utility method checking if the `value` is in range.
+        """
+
+
+@dataclass
+class TypeIdentifier(CairoType):
+    """
+    Type representation of Cairo identifiers.
+    """
+
+    name: str
+
+
+@dataclass
+class UnitType(CairoType):
+    """
+    Type representation of Cairo unit `()`.
+    """
+
+
+@dataclass
+class EventType(CairoType):
+    """
+    Type representation of Cairo Event.
+    """
+
+    name: str
+    types: OrderedDict[str, CairoType]

coinex/ccxt/static_dependencies/starknet/cairo/deprecated_parse/cairo_types.py

@@ -0,0 +1,77 @@
+import dataclasses
+from typing import List, Optional
+
+
+class CairoType:
+    """
+    Base class for cairo types.
+    """
+
+
+@dataclasses.dataclass
+class TypeFelt(CairoType):
+    pass
+
+
+@dataclasses.dataclass
+class TypeCodeoffset(CairoType):
+    pass
+
+
+@dataclasses.dataclass
+class TypePointer(CairoType):
+    pointee: CairoType
+
+
+@dataclasses.dataclass
+class TypeIdentifier(CairoType):
+    """
+    Represents a name of an unresolved type.
+    This type can be resolved to TypeStruct or TypeDefinition.
+    """
+
+    name: str
+
+
+@dataclasses.dataclass
+class TypeStruct(CairoType):
+    scope: str
+
+
+@dataclasses.dataclass
+class TypeFunction(CairoType):
+    """
+    Represents a type of a function.
+    """
+
+    scope: str
+
+
+@dataclasses.dataclass
+class TypeTuple(CairoType):
+    """
+    Represents a type of a named or unnamed tuple.
+    For example, "(felt, felt*)" or "(a: felt, b: felt*)".
+    """
+
+    @dataclasses.dataclass
+    class Item(CairoType):
+        """
+        Represents a possibly named type item of a TypeTuple.
+        For example: "felt" or "a: felt".
+        """
+
+        name: Optional[str]
+        typ: CairoType
+
+    members: List["TypeTuple.Item"]
+    has_trailing_comma: bool = dataclasses.field(hash=False, compare=False)
+
+    @property
+    def is_named(self) -> bool:
+        return all(member.name is not None for member in self.members)
+
+
+@dataclasses.dataclass
+class ExprIdentifier(CairoType):
+    name: str

coinex/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

coinex/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)

coinex/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")