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

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

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

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

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

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

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

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

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