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

coinex/ccxt/static_dependencies/ethereum/abi/exceptions.py

@@ -0,0 +1,139 @@
+from ...parsimonious import (
+    ParseError
+)
+
+
+class EncodingError(Exception):
+    """
+    Base exception for any error that occurs during encoding.
+    """
+
+    pass
+
+
+class EncodingTypeError(EncodingError):
+    """
+    Raised when trying to encode a python value whose type is not supported for
+    the output ABI type.
+    """
+
+    pass
+
+
+class IllegalValue(EncodingError):
+    """
+    Raised when trying to encode a python value with the correct type but with
+    a value that is not considered legal for the output ABI type.
+
+    Example:
+
+    .. code-block:: python
+
+        fixed128x19_encoder(Decimal('NaN'))  # cannot encode NaN
+
+    """
+
+    pass
+
+
+class ValueOutOfBounds(IllegalValue):
+    """
+    Raised when trying to encode a python value with the correct type but with
+    a value that appears outside the range of valid values for the output ABI
+    type.
+
+    Example:
+
+    .. code-block:: python
+
+        ufixed8x1_encoder(Decimal('25.6'))  # out of bounds
+
+    """
+
+    pass
+
+
+class DecodingError(Exception):
+    """
+    Base exception for any error that occurs during decoding.
+    """
+
+    pass
+
+
+class InsufficientDataBytes(DecodingError):
+    """
+    Raised when there are insufficient data to decode a value for a given ABI
+    type.
+    """
+
+    pass
+
+
+class NonEmptyPaddingBytes(DecodingError):
+    """
+    Raised when the padding bytes of an ABI value are malformed.
+    """
+
+    pass
+
+
+class ParseError(ParseError):
+    """
+    Raised when an ABI type string cannot be parsed.
+    """
+
+    def __str__(self):
+        return "Parse error at '{}' (column {}) in type string '{}'".format(
+            self.text[self.pos : self.pos + 5],
+            self.column(),
+            self.text,
+        )
+
+
+class ABITypeError(ValueError):
+    """
+    Raised when a parsed ABI type has inconsistent properties; for example,
+    when trying to parse the type string ``'uint7'`` (which has a bit-width
+    that is not congruent with zero modulo eight).
+    """
+
+    pass
+
+
+class PredicateMappingError(Exception):
+    """
+    Raised when an error occurs in a registry's internal mapping.
+    """
+
+    pass
+
+
+class NoEntriesFound(ValueError, PredicateMappingError):
+    """
+    Raised when no registration is found for a type string in a registry's
+    internal mapping.
+
+    .. warning::
+
+        In a future version of ``eth-abi``, this error class will no longer
+        inherit from ``ValueError``.
+    """
+
+    pass
+
+
+class MultipleEntriesFound(ValueError, PredicateMappingError):
+    """
+    Raised when multiple registrations are found for a type string in a
+    registry's internal mapping.  This error is non-recoverable and indicates
+    that a registry was configured incorrectly.  Registrations are expected to
+    cover completely distinct ranges of type strings.
+
+    .. warning::
+
+        In a future version of ``eth-abi``, this error class will no longer
+        inherit from ``ValueError``.
+    """
+
+    pass

coinex/ccxt/static_dependencies/ethereum/abi/grammar.py

@@ -0,0 +1,443 @@
+import functools
+import re
+
+from ...parsimonious import (
+    expressions,
+    ParseError,
+    NodeVisitor,
+    Grammar
+)
+
+from .exceptions import (
+    ABITypeError,
+    ParseError,
+)
+
+grammar = Grammar(
+    r"""
+    type = tuple_type / basic_type
+
+    tuple_type = components arrlist?
+    components = non_zero_tuple / zero_tuple
+
+    non_zero_tuple = "(" type next_type* ")"
+    next_type = "," type
+
+    zero_tuple = "()"
+
+    basic_type = base sub? arrlist?
+
+    base = alphas
+
+    sub = two_size / digits
+    two_size = (digits "x" digits)
+
+    arrlist = (const_arr / dynam_arr)+
+    const_arr = "[" digits "]"
+    dynam_arr = "[]"
+
+    alphas = ~"[A-Za-z]+"
+    digits = ~"[1-9][0-9]*"
+    """
+)
+
+
+class NodeVisitor(NodeVisitor):
+    """
+    Parsimonious node visitor which performs both parsing of type strings and
+    post-processing of parse trees.  Parsing operations are cached.
+    """
+
+    grammar = grammar
+
+    def visit_non_zero_tuple(self, node, visited_children):
+        # Ignore left and right parens
+        _, first, rest, _ = visited_children
+
+        return (first,) + rest
+
+    def visit_tuple_type(self, node, visited_children):
+        components, arrlist = visited_children
+
+        return TupleType(components, arrlist, node=node)
+
+    def visit_next_type(self, node, visited_children):
+        # Ignore comma
+        _, abi_type = visited_children
+
+        return abi_type
+
+    def visit_zero_tuple(self, node, visited_children):
+        return tuple()
+
+    def visit_basic_type(self, node, visited_children):
+        base, sub, arrlist = visited_children
+
+        return BasicType(base, sub, arrlist, node=node)
+
+    def visit_two_size(self, node, visited_children):
+        # Ignore "x"
+        first, _, second = visited_children
+
+        return first, second
+
+    def visit_const_arr(self, node, visited_children):
+        # Ignore left and right brackets
+        _, int_value, _ = visited_children
+
+        return (int_value,)
+
+    def visit_dynam_arr(self, node, visited_children):
+        return tuple()
+
+    def visit_alphas(self, node, visited_children):
+        return node.text
+
+    def visit_digits(self, node, visited_children):
+        return int(node.text)
+
+    def generic_visit(self, node, visited_children):
+        if isinstance(node.expr, expressions.OneOf):
+            # Unwrap value chosen from alternatives
+            return visited_children[0]
+        if isinstance(node.expr, expressions.Optional):
+            # Unwrap optional value or return `None`
+            if len(visited_children) != 0:
+                return visited_children[0]
+
+            return None
+
+        return tuple(visited_children)
+
+    @functools.lru_cache(maxsize=None)
+    def parse(self, type_str):
+        """
+        Parses a type string into an appropriate instance of
+        :class:`~eth_abi.grammar.ABIType`.  If a type string cannot be parsed,
+        throws :class:`~eth_abi.exceptions.ParseError`.
+
+        :param type_str: The type string to be parsed.
+        :returns: An instance of :class:`~eth_abi.grammar.ABIType` containing
+            information about the parsed type string.
+        """
+        if not isinstance(type_str, str):
+            raise TypeError(
+                "Can only parse string values: got {}".format(type(type_str))
+            )
+
+        try:
+            return super().parse(type_str)
+        except ParseError as e:
+            raise ParseError(e.text, e.pos, e.expr)
+
+
+visitor = NodeVisitor()
+
+
+class ABIType:
+    """
+    Base class for results of type string parsing operations.
+    """
+
+    __slots__ = ("arrlist", "node")
+
+    def __init__(self, arrlist=None, node=None):
+        self.arrlist = arrlist
+        """
+        The list of array dimensions for a parsed type.  Equal to ``None`` if
+        type string has no array dimensions.
+        """
+
+        self.node = node
+        """
+        The parsimonious ``Node`` instance associated with this parsed type.
+        Used to generate error messages for invalid types.
+        """
+
+    def __repr__(self):  # pragma: no cover
+        return "<{} {}>".format(
+            type(self).__qualname__,
+            repr(self.to_type_str()),
+        )
+
+    def __eq__(self, other):
+        # Two ABI types are equal if their string representations are equal
+        return type(self) is type(other) and self.to_type_str() == other.to_type_str()
+
+    def to_type_str(self):  # pragma: no cover
+        """
+        Returns the string representation of an ABI type.  This will be equal to
+        the type string from which it was created.
+        """
+        raise NotImplementedError("Must implement `to_type_str`")
+
+    @property
+    def item_type(self):
+        """
+        If this type is an array type, equal to an appropriate
+        :class:`~eth_abi.grammar.ABIType` instance for the array's items.
+        """
+        raise NotImplementedError("Must implement `item_type`")
+
+    def validate(self):  # pragma: no cover
+        """
+        Validates the properties of an ABI type against the solidity ABI spec:
+
+        https://solidity.readthedocs.io/en/develop/abi-spec.html
+
+        Raises :class:`~eth_abi.exceptions.ABITypeError` if validation fails.
+        """
+        raise NotImplementedError("Must implement `validate`")
+
+    def invalidate(self, error_msg):
+        # Invalidates an ABI type with the given error message.  Expects that a
+        # parsimonious node was provided from the original parsing operation
+        # that yielded this type.
+        node = self.node
+
+        raise ABITypeError(
+            "For '{comp_str}' type at column {col} "
+            "in '{type_str}': {error_msg}".format(
+                comp_str=node.text,
+                col=node.start + 1,
+                type_str=node.full_text,
+                error_msg=error_msg,
+            ),
+        )
+
+    @property
+    def is_array(self):
+        """
+        Equal to ``True`` if a type is an array type (i.e. if it has an array
+        dimension list).  Otherwise, equal to ``False``.
+        """
+        return self.arrlist is not None
+
+    @property
+    def is_dynamic(self):
+        """
+        Equal to ``True`` if a type has a dynamically sized encoding.
+        Otherwise, equal to ``False``.
+        """
+        raise NotImplementedError("Must implement `is_dynamic`")
+
+    @property
+    def _has_dynamic_arrlist(self):
+        return self.is_array and any(len(dim) == 0 for dim in self.arrlist)
+
+
+class TupleType(ABIType):
+    """
+    Represents the result of parsing a tuple type string e.g. "(int,bool)".
+    """
+
+    __slots__ = ("components",)
+
+    def __init__(self, components, arrlist=None, *, node=None):
+        super().__init__(arrlist, node)
+
+        self.components = components
+        """
+        A tuple of :class:`~eth_abi.grammar.ABIType` instances for each of the
+        tuple type's components.
+        """
+
+    def to_type_str(self):
+        arrlist = self.arrlist
+
+        if isinstance(arrlist, tuple):
+            arrlist = "".join(repr(list(a)) for a in arrlist)
+        else:
+            arrlist = ""
+
+        return "({}){}".format(
+            ",".join(c.to_type_str() for c in self.components),
+            arrlist,
+        )
+
+    @property
+    def item_type(self):
+        if not self.is_array:
+            raise ValueError(
+                "Cannot determine item type for non-array type '{}'".format(
+                    self.to_type_str(),
+                )
+            )
+
+        return type(self)(
+            self.components,
+            self.arrlist[:-1] or None,
+            node=self.node,
+        )
+
+    def validate(self):
+        for c in self.components:
+            c.validate()
+
+    @property
+    def is_dynamic(self):
+        if self._has_dynamic_arrlist:
+            return True
+
+        return any(c.is_dynamic for c in self.components)
+
+
+class BasicType(ABIType):
+    """
+    Represents the result of parsing a basic type string e.g. "uint", "address",
+    "ufixed128x19[][2]".
+    """
+
+    __slots__ = ("base", "sub")
+
+    def __init__(self, base, sub=None, arrlist=None, *, node=None):
+        super().__init__(arrlist, node)
+
+        self.base = base
+        """The base of a basic type e.g. "uint" for "uint256" etc."""
+
+        self.sub = sub
+        """
+        The sub type of a basic type e.g. ``256`` for "uint256" or ``(128, 18)``
+        for "ufixed128x18" etc.  Equal to ``None`` if type string has no sub
+        type.
+        """
+
+    def to_type_str(self):
+        sub, arrlist = self.sub, self.arrlist
+
+        if isinstance(sub, int):
+            sub = str(sub)
+        elif isinstance(sub, tuple):
+            sub = "x".join(str(s) for s in sub)
+        else:
+            sub = ""
+
+        if isinstance(arrlist, tuple):
+            arrlist = "".join(repr(list(a)) for a in arrlist)
+        else:
+            arrlist = ""
+
+        return self.base + sub + arrlist
+
+    @property
+    def item_type(self):
+        if not self.is_array:
+            raise ValueError(
+                "Cannot determine item type for non-array type '{}'".format(
+                    self.to_type_str(),
+                )
+            )
+
+        return type(self)(
+            self.base,
+            self.sub,
+            self.arrlist[:-1] or None,
+            node=self.node,
+        )
+
+    @property
+    def is_dynamic(self):
+        if self._has_dynamic_arrlist:
+            return True
+
+        if self.base == "string":
+            return True
+
+        if self.base == "bytes" and self.sub is None:
+            return True
+
+        return False
+
+    def validate(self):
+        base, sub = self.base, self.sub
+
+        # Check validity of string type
+        if base == "string":
+            if sub is not None:
+                self.invalidate("string type cannot have suffix")
+
+        # Check validity of bytes type
+        elif base == "bytes":
+            if not (sub is None or isinstance(sub, int)):
+                self.invalidate(
+                    "bytes type must have either no suffix or a numerical suffix"
+                )
+
+            if isinstance(sub, int) and sub > 32:
+                self.invalidate("maximum 32 bytes for fixed-length bytes")
+
+        # Check validity of integer type
+        elif base in ("int", "uint"):
+            if not isinstance(sub, int):
+                self.invalidate("integer type must have numerical suffix")
+
+            if sub < 8 or 256 < sub:
+                self.invalidate("integer size out of bounds (max 256 bits)")
+
+            if sub % 8 != 0:
+                self.invalidate("integer size must be multiple of 8")
+
+        # Check validity of fixed type
+        elif base in ("fixed", "ufixed"):
+            if not isinstance(sub, tuple):
+                self.invalidate(
+                    "fixed type must have suffix of form <bits>x<exponent>, "
+                    "e.g. 128x19",
+                )
+
+            bits, minus_e = sub
+
+            if bits < 8 or 256 < bits:
+                self.invalidate("fixed size out of bounds (max 256 bits)")
+
+            if bits % 8 != 0:
+                self.invalidate("fixed size must be multiple of 8")
+
+            if minus_e < 1 or 80 < minus_e:
+                self.invalidate(
+                    "fixed exponent size out of bounds, {} must be in 1-80".format(
+                        minus_e,
+                    ),
+                )
+
+        # Check validity of hash type
+        elif base == "hash":
+            if not isinstance(sub, int):
+                self.invalidate("hash type must have numerical suffix")
+
+        # Check validity of address type
+        elif base == "address":
+            if sub is not None:
+                self.invalidate("address cannot have suffix")
+
+
+TYPE_ALIASES = {
+    "int": "int256",
+    "uint": "uint256",
+    "fixed": "fixed128x18",
+    "ufixed": "ufixed128x18",
+    "function": "bytes24",
+    "byte": "bytes1",
+}
+
+TYPE_ALIAS_RE = re.compile(
+    r"\b({})\b".format("|".join(re.escape(a) for a in TYPE_ALIASES.keys()))
+)
+
+
+def normalize(type_str):
+    """
+    Normalizes a type string into its canonical version e.g. the type string
+    'int' becomes 'int256', etc.
+
+    :param type_str: The type string to be normalized.
+    :returns: The canonical version of the input type string.
+    """
+    return TYPE_ALIAS_RE.sub(
+        lambda match: TYPE_ALIASES[match.group(0)],
+        type_str,
+    )
+
+
+parse = visitor.parse

coinex/ccxt/static_dependencies/ethereum/abi/packed.py

@@ -0,0 +1,13 @@
+from .codec import (
+    ABIEncoder,
+)
+from .registry import (
+    registry_packed,
+)
+
+default_encoder_packed = ABIEncoder(registry_packed)
+
+encode_packed = default_encoder_packed.encode
+is_encodable_packed = default_encoder_packed.is_encodable
+encode_single_packed = default_encoder_packed.encode_single  # deprecated
+encode_abi_packed = default_encoder_packed.encode_abi  # deprecated