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

coinex/ccxt/static_dependencies/ecdsa/util.py

@@ -0,0 +1,266 @@
+from __future__ import division
+
+import os
+import math
+import binascii
+from hashlib import sha256
+from . import der
+from .curves import orderlen
+
+# RFC5480:
+#   The "unrestricted" algorithm identifier is:
+#     id-ecPublicKey OBJECT IDENTIFIER ::= {
+#       iso(1) member-body(2) us(840) ansi-X9-62(10045) keyType(2) 1 }
+
+oid_ecPublicKey = (1, 2, 840, 10045, 2, 1)
+encoded_oid_ecPublicKey = der.encode_oid(*oid_ecPublicKey)
+
+
+def randrange(order, entropy=None):
+    """Return a random integer k such that 1 <= k < order, uniformly
+    distributed across that range. For simplicity, this only behaves well if
+    'order' is fairly close (but below) a power of 256. The try-try-again
+    algorithm we use takes longer and longer time (on average) to complete as
+    'order' falls, rising to a maximum of avg=512 loops for the worst-case
+    (256**k)+1 . All of the standard curves behave well. There is a cutoff at
+    10k loops (which raises RuntimeError) to prevent an infinite loop when
+    something is really broken like the entropy function not working.
+
+    Note that this function is not declared to be forwards-compatible: we may
+    change the behavior in future releases. The entropy= argument (which
+    should get a callable that behaves like os.urandom) can be used to
+    achieve stability within a given release (for repeatable unit tests), but
+    should not be used as a long-term-compatible key generation algorithm.
+    """
+    # we could handle arbitrary orders (even 256**k+1) better if we created
+    # candidates bit-wise instead of byte-wise, which would reduce the
+    # worst-case behavior to avg=2 loops, but that would be more complex. The
+    # change would be to round the order up to a power of 256, subtract one
+    # (to get 0xffff..), use that to get a byte-long mask for the top byte,
+    # generate the len-1 entropy bytes, generate one extra byte and mask off
+    # the top bits, then combine it with the rest. Requires jumping back and
+    # forth between strings and integers a lot.
+
+    if entropy is None:
+        entropy = os.urandom
+    assert order > 1
+    bytes = orderlen(order)
+    dont_try_forever = 10000  # gives about 2**-60 failures for worst case
+    while dont_try_forever > 0:
+        dont_try_forever -= 1
+        candidate = string_to_number(entropy(bytes)) + 1
+        if 1 <= candidate < order:
+            return candidate
+        continue
+    raise RuntimeError("randrange() tried hard but gave up, either something"
+                       " is very wrong or you got realllly unlucky. Order was"
+                       " %x" % order)
+
+
+class PRNG:
+    # this returns a callable which, when invoked with an integer N, will
+    # return N pseudorandom bytes. Note: this is a short-term PRNG, meant
+    # primarily for the needs of randrange_from_seed__trytryagain(), which
+    # only needs to run it a few times per seed. It does not provide
+    # protection against state compromise (forward security).
+    def __init__(self, seed):
+        self.generator = self.block_generator(seed)
+
+    def __call__(self, numbytes):
+        a = [next(self.generator) for i in range(numbytes)]
+        return bytes(a)
+
+    def block_generator(self, seed):
+        counter = 0
+        while True:
+            for byte in sha256(("prng-%d-%s" % (counter, seed)).encode()).digest():
+                yield byte
+            counter += 1
+
+
+def randrange_from_seed__overshoot_modulo(seed, order):
+    # hash the data, then turn the digest into a number in [1,order).
+    #
+    # We use David-Sarah Hopwood's suggestion: turn it into a number that's
+    # sufficiently larger than the group order, then modulo it down to fit.
+    # This should give adequate (but not perfect) uniformity, and simple
+    # code. There are other choices: try-try-again is the main one.
+    base = PRNG(seed)(2 * orderlen(order))
+    number = (int(binascii.hexlify(base), 16) % (order - 1)) + 1
+    assert 1 <= number < order, (1, number, order)
+    return number
+
+
+def lsb_of_ones(numbits):
+    return (1 << numbits) - 1
+
+
+def bits_and_bytes(order):
+    bits = int(math.log(order - 1, 2) + 1)
+    bytes = bits // 8
+    extrabits = bits % 8
+    return bits, bytes, extrabits
+
+
+# the following randrange_from_seed__METHOD() functions take an
+# arbitrarily-sized secret seed and turn it into a number that obeys the same
+# range limits as randrange() above. They are meant for deriving consistent
+# signing keys from a secret rather than generating them randomly, for
+# example a protocol in which three signing keys are derived from a master
+# secret. You should use a uniformly-distributed unguessable seed with about
+# curve.baselen bytes of entropy. To use one, do this:
+#   seed = os.urandom(curve.baselen) # or other starting point
+#   secexp = ecdsa.util.randrange_from_seed__trytryagain(sed, curve.order)
+#   sk = SigningKey.from_secret_exponent(secexp, curve)
+
+def randrange_from_seed__truncate_bytes(seed, order, hashmod=sha256):
+    # hash the seed, then turn the digest into a number in [1,order), but
+    # don't worry about trying to uniformly fill the range. This will lose,
+    # on average, four bits of entropy.
+    bits, _bytes, extrabits = bits_and_bytes(order)
+    if extrabits:
+        _bytes += 1
+    base = hashmod(seed).digest()[:_bytes]
+    base = "\x00" * (_bytes - len(base)) + base
+    number = 1 + int(binascii.hexlify(base), 16)
+    assert 1 <= number < order
+    return number
+
+
+def randrange_from_seed__truncate_bits(seed, order, hashmod=sha256):
+    # like string_to_randrange_truncate_bytes, but only lose an average of
+    # half a bit
+    bits = int(math.log(order - 1, 2) + 1)
+    maxbytes = (bits + 7) // 8
+    base = hashmod(seed).digest()[:maxbytes]
+    base = "\x00" * (maxbytes - len(base)) + base
+    topbits = 8 * maxbytes - bits
+    if topbits:
+        base = int.to_bytes(ord(base[0]) & lsb_of_ones(topbits), 1, 'big') + base[1:]
+    number = 1 + int(binascii.hexlify(base), 16)
+    assert 1 <= number < order
+    return number
+
+
+def randrange_from_seed__trytryagain(seed, order):
+    # figure out exactly how many bits we need (rounded up to the nearest
+    # bit), so we can reduce the chance of looping to less than 0.5 . This is
+    # specified to feed from a byte-oriented PRNG, and discards the
+    # high-order bits of the first byte as necessary to get the right number
+    # of bits. The average number of loops will range from 1.0 (when
+    # order=2**k-1) to 2.0 (when order=2**k+1).
+    assert order > 1
+    bits, bytes, extrabits = bits_and_bytes(order)
+    generate = PRNG(seed)
+    while True:
+        extrabyte = b''
+        if extrabits:
+            extrabyte = int.to_bytes(ord(generate(1)) & lsb_of_ones(extrabits), 1, 'big')
+        guess = string_to_number(extrabyte + generate(bytes)) + 1
+        if 1 <= guess < order:
+            return guess
+
+
+def number_to_string(num, order):
+    l = orderlen(order)
+    fmt_str = "%0" + str(2 * l) + "x"
+    string = binascii.unhexlify((fmt_str % num).encode())
+    assert len(string) == l, (len(string), l)
+    return string
+
+
+def number_to_string_crop(num, order):
+    l = orderlen(order)
+    fmt_str = "%0" + str(2 * l) + "x"
+    string = binascii.unhexlify((fmt_str % num).encode())
+    return string[:l]
+
+
+def string_to_number(string):
+    return int(binascii.hexlify(string), 16)
+
+
+def string_to_number_fixedlen(string, order):
+    l = orderlen(order)
+    assert len(string) == l, (len(string), l)
+    return int(binascii.hexlify(string), 16)
+
+
+# these methods are useful for the sigencode= argument to SK.sign() and the
+# sigdecode= argument to VK.verify(), and control how the signature is packed
+# or unpacked.
+
+def sigencode_strings(r, s, order, v=None):
+    r_str = number_to_string(r, order)
+    s_str = number_to_string(s, order)
+    return r_str, s_str, v
+
+
+def sigencode_string(r, s, order, v=None):
+    # for any given curve, the size of the signature numbers is
+    # fixed, so just use simple concatenation
+    r_str, s_str, v = sigencode_strings(r, s, order)
+    return r_str + s_str
+
+
+def sigencode_der(r, s, order, v=None):
+    return der.encode_sequence(der.encode_integer(r), der.encode_integer(s))
+
+
+# canonical versions of sigencode methods
+# these enforce low S values, by negating the value (modulo the order) if above order/2
+# see CECKey::Sign() https://github.com/bitcoin/bitcoin/blob/master/src/key.cpp#L214
+def sigencode_strings_canonize(r, s, order, v=None):
+    if s > order / 2:
+        s = order - s
+        if v is not None:
+            v ^= 1
+    return sigencode_strings(r, s, order, v)
+
+
+def sigencode_string_canonize(r, s, order, v=None):
+    if s > order / 2:
+        s = order - s
+        if v is not None:
+            v ^= 1
+    return sigencode_string(r, s, order, v)
+
+
+def sigencode_der_canonize(r, s, order, v=None):
+    if s > order / 2:
+        s = order - s
+        if v is not None:
+            v ^= 1
+    return sigencode_der(r, s, order, v)
+
+
+def sigdecode_string(signature, order):
+    l = orderlen(order)
+    assert len(signature) == 2 * l, (len(signature), 2 * l)
+    r = string_to_number_fixedlen(signature[:l], order)
+    s = string_to_number_fixedlen(signature[l:], order)
+    return r, s
+
+
+def sigdecode_strings(rs_strings, order):
+    (r_str, s_str) = rs_strings
+    l = orderlen(order)
+    assert len(r_str) == l, (len(r_str), l)
+    assert len(s_str) == l, (len(s_str), l)
+    r = string_to_number_fixedlen(r_str, order)
+    s = string_to_number_fixedlen(s_str, order)
+    return r, s
+
+
+def sigdecode_der(sig_der, order):
+    # return der.encode_sequence(der.encode_integer(r), der.encode_integer(s))
+    rs_strings, empty = der.remove_sequence(sig_der)
+    if empty != b'':
+        raise der.UnexpectedDER("trailing junk after DER sig: %s" %
+                                binascii.hexlify(empty))
+    r, rest = der.remove_integer(rs_strings)
+    s, empty = der.remove_integer(rest)
+    if empty != b'':
+        raise der.UnexpectedDER("trailing junk after DER numbers: %s" %
+                                binascii.hexlify(empty))
+    return r, s

coinex/ccxt/static_dependencies/ethereum/__init__.py

@@ -0,0 +1,7 @@
+from .abi import *
+from .account import *
+from .typing import *
+from .utils import *
+from .hexbytes import *
+
+__all__ = [ 'account', 'typing', 'utils', 'abi', 'hexbytes' ]

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

@@ -0,0 +1,16 @@
+
+from .abi import (
+    decode,
+    decode_abi,
+    decode_single,
+    encode,
+    encode_abi,
+    encode_single,
+    is_encodable,
+    is_encodable_type,
+)
+
+# This code from: https://github.com/ethereum/eth-abi/tree/v3.0.1
+__version__ = 'ccxt'
+
+__all__ = ['decode','encode']

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

@@ -0,0 +1,19 @@
+from .codec import (
+    ABICodec,
+)
+from .registry import (
+    registry,
+)
+
+default_codec = ABICodec(registry)
+
+encode = default_codec.encode
+encode_abi = default_codec.encode_abi  # deprecated
+encode_single = default_codec.encode_single  # deprecated
+
+decode = default_codec.decode
+decode_abi = default_codec.decode_abi  # deprecated
+decode_single = default_codec.decode_single  # deprecated
+
+is_encodable = default_codec.is_encodable
+is_encodable_type = default_codec.is_encodable_type

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

@@ -0,0 +1,152 @@
+import functools
+
+from ..typing.abi import (
+    TypeStr,
+)
+
+from .grammar import (
+    BasicType,
+    TupleType,
+    normalize,
+    parse,
+)
+
+
+def parse_type_str(expected_base=None, with_arrlist=False):
+    """
+    Used by BaseCoder subclasses as a convenience for implementing the
+    ``from_type_str`` method required by ``ABIRegistry``.  Useful if normalizing
+    then parsing a type string with an (optional) expected base is required in
+    that method.
+    """
+
+    def decorator(old_from_type_str):
+        @functools.wraps(old_from_type_str)
+        def new_from_type_str(cls, type_str, registry):
+            normalized_type_str = normalize(type_str)
+            abi_type = parse(normalized_type_str)
+
+            type_str_repr = repr(type_str)
+            if type_str != normalized_type_str:
+                type_str_repr = "{} (normalized to {})".format(
+                    type_str_repr,
+                    repr(normalized_type_str),
+                )
+
+            if expected_base is not None:
+                if not isinstance(abi_type, BasicType):
+                    raise ValueError(
+                        "Cannot create {} for non-basic type {}".format(
+                            cls.__name__,
+                            type_str_repr,
+                        )
+                    )
+                if abi_type.base != expected_base:
+                    raise ValueError(
+                        "Cannot create {} for type {}: expected type with "
+                        "base '{}'".format(
+                            cls.__name__,
+                            type_str_repr,
+                            expected_base,
+                        )
+                    )
+
+            if not with_arrlist and abi_type.arrlist is not None:
+                raise ValueError(
+                    "Cannot create {} for type {}: expected type with "
+                    "no array dimension list".format(
+                        cls.__name__,
+                        type_str_repr,
+                    )
+                )
+            if with_arrlist and abi_type.arrlist is None:
+                raise ValueError(
+                    "Cannot create {} for type {}: expected type with "
+                    "array dimension list".format(
+                        cls.__name__,
+                        type_str_repr,
+                    )
+                )
+
+            # Perform general validation of default solidity types
+            abi_type.validate()
+
+            return old_from_type_str(cls, abi_type, registry)
+
+        return classmethod(new_from_type_str)
+
+    return decorator
+
+
+def parse_tuple_type_str(old_from_type_str):
+    """
+    Used by BaseCoder subclasses as a convenience for implementing the
+    ``from_type_str`` method required by ``ABIRegistry``.  Useful if normalizing
+    then parsing a tuple type string is required in that method.
+    """
+
+    @functools.wraps(old_from_type_str)
+    def new_from_type_str(cls, type_str, registry):
+        normalized_type_str = normalize(type_str)
+        abi_type = parse(normalized_type_str)
+
+        type_str_repr = repr(type_str)
+        if type_str != normalized_type_str:
+            type_str_repr = "{} (normalized to {})".format(
+                type_str_repr,
+                repr(normalized_type_str),
+            )
+
+        if not isinstance(abi_type, TupleType):
+            raise ValueError(
+                "Cannot create {} for non-tuple type {}".format(
+                    cls.__name__,
+                    type_str_repr,
+                )
+            )
+
+        abi_type.validate()
+
+        return old_from_type_str(cls, abi_type, registry)
+
+    return classmethod(new_from_type_str)
+
+
+class BaseCoder:
+    """
+    Base class for all encoder and decoder classes.
+    """
+
+    is_dynamic = False
+
+    def __init__(self, **kwargs):
+        cls = type(self)
+
+        # Ensure no unrecognized kwargs were given
+        for key, value in kwargs.items():
+            if not hasattr(cls, key):
+                raise AttributeError(
+                    "Property {key} not found on {cls_name} class. "
+                    "`{cls_name}.__init__` only accepts keyword arguments which are "
+                    "present on the {cls_name} class.".format(
+                        key=key,
+                        cls_name=cls.__name__,
+                    )
+                )
+            setattr(self, key, value)
+
+        # Validate given combination of kwargs
+        self.validate()
+
+    def validate(self):
+        pass
+
+    @classmethod
+    def from_type_str(
+        cls, type_str: TypeStr, registry
+    ) -> "BaseCoder":  # pragma: no cover
+        """
+        Used by :any:`ABIRegistry` to get an appropriate encoder or decoder
+        instance for the given type string and type registry.
+        """
+        raise NotImplementedError("Must implement `from_type_str`")

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

@@ -0,0 +1,217 @@
+from typing import (
+    Any,
+    Iterable,
+    Tuple,
+)
+import warnings
+
+from ..typing.abi import (
+    Decodable,
+    TypeStr,
+)
+from ..utils import (
+    is_bytes,
+)
+
+from .decoding import (
+    ContextFramesBytesIO,
+    TupleDecoder,
+)
+from .encoding import (
+    TupleEncoder,
+)
+from .exceptions import (
+    EncodingError,
+)
+from .registry import (
+    ABIRegistry,
+)
+
+
+class BaseABICoder:
+    """
+    Base class for porcelain coding APIs.  These are classes which wrap
+    instances of :class:`~.registry.ABIRegistry` to provide last-mile
+    coding functionality.
+    """
+
+    def __init__(self, registry: ABIRegistry):
+        """
+        Constructor.
+
+        :param registry: The registry providing the encoders to be used when
+            encoding values.
+        """
+        self._registry = registry
+
+
+class ABIEncoder(BaseABICoder):
+    """
+    Wraps a registry to provide last-mile encoding functionality.
+    """
+
+    def encode_single(self, typ: TypeStr, arg: Any) -> bytes:
+        """
+        Encodes the python value ``arg`` as a binary value of the ABI type
+        ``typ``.
+
+        :param typ: The string representation of the ABI type that will be used
+            for encoding e.g. ``'uint256'``, ``'bytes[]'``, ``'(int,int)'``,
+            etc.
+        :param arg: The python value to be encoded.
+
+        :returns: The binary representation of the python value ``arg`` as a
+            value of the ABI type ``typ``.
+        """
+        warnings.warn(
+            "abi.encode_single() and abi.encode_single_packed() are deprecated "
+            "and will be removed in version 4.0.0 in favor of abi.encode() and "
+            "abi.encode_packed(), respectively",
+            category=DeprecationWarning,
+        )
+
+        encoder = self._registry.get_encoder(typ)
+
+        return encoder(arg)
+
+    def encode_abi(self, types: Iterable[TypeStr], args: Iterable[Any]) -> bytes:
+        """
+        Encodes the python values in ``args`` as a sequence of binary values of
+        the ABI types in ``types`` via the head-tail mechanism.
+
+        :param types: An iterable of string representations of the ABI types
+            that will be used for encoding e.g.  ``('uint256', 'bytes[]',
+            '(int,int)')``
+        :param args: An iterable of python values to be encoded.
+
+        :returns: The head-tail encoded binary representation of the python
+            values in ``args`` as values of the ABI types in ``types``.
+        """
+        warnings.warn(
+            "abi.encode_abi() and abi.encode_abi_packed() are deprecated and will be "
+            "removed in version 4.0.0 in favor of abi.encode() and "
+            "abi.encode_packed(), respectively",
+            category=DeprecationWarning,
+        )
+        return self.encode(types, args)
+
+    def encode(self, types, args):
+        encoders = [self._registry.get_encoder(type_str) for type_str in types]
+
+        encoder = TupleEncoder(encoders=encoders)
+
+        return encoder(args)
+
+    def is_encodable(self, typ: TypeStr, arg: Any) -> bool:
+        """
+        Determines if the python value ``arg`` is encodable as a value of the
+        ABI type ``typ``.
+
+        :param typ: A string representation for the ABI type against which the
+            python value ``arg`` will be checked e.g. ``'uint256'``,
+            ``'bytes[]'``, ``'(int,int)'``, etc.
+        :param arg: The python value whose encodability should be checked.
+
+        :returns: ``True`` if ``arg`` is encodable as a value of the ABI type
+            ``typ``.  Otherwise, ``False``.
+        """
+        encoder = self._registry.get_encoder(typ)
+
+        try:
+            encoder.validate_value(arg)
+        except EncodingError:
+            return False
+        except AttributeError:
+            try:
+                encoder(arg)
+            except EncodingError:
+                return False
+
+        return True
+
+    def is_encodable_type(self, typ: TypeStr) -> bool:
+        """
+        Returns ``True`` if values for the ABI type ``typ`` can be encoded by
+        this codec.
+
+        :param typ: A string representation for the ABI type that will be
+            checked for encodability e.g. ``'uint256'``, ``'bytes[]'``,
+            ``'(int,int)'``, etc.
+
+        :returns: ``True`` if values for ``typ`` can be encoded by this codec.
+            Otherwise, ``False``.
+        """
+        return self._registry.has_encoder(typ)
+
+
+class ABIDecoder(BaseABICoder):
+    """
+    Wraps a registry to provide last-mile decoding functionality.
+    """
+
+    stream_class = ContextFramesBytesIO
+
+    def decode_single(self, typ: TypeStr, data: Decodable) -> Any:
+        """
+        Decodes the binary value ``data`` of the ABI type ``typ`` into its
+        equivalent python value.
+
+        :param typ: The string representation of the ABI type that will be used for
+            decoding e.g. ``'uint256'``, ``'bytes[]'``, ``'(int,int)'``, etc.
+        :param data: The binary value to be decoded.
+
+        :returns: The equivalent python value of the ABI value represented in
+            ``data``.
+        """
+        warnings.warn(
+            "abi.decode_single() is deprecated and will be removed in version 4.0.0 "
+            "in favor of abi.decode()",
+            category=DeprecationWarning,
+        )
+
+        if not is_bytes(data):
+            raise TypeError(
+                "The `data` value must be of bytes type.  Got {0}".format(type(data))
+            )
+
+        decoder = self._registry.get_decoder(typ)
+        stream = self.stream_class(data)
+
+        return decoder(stream)
+
+    def decode_abi(self, types: Iterable[TypeStr], data: Decodable) -> Tuple[Any, ...]:
+        """
+        Decodes the binary value ``data`` as a sequence of values of the ABI types
+        in ``types`` via the head-tail mechanism into a tuple of equivalent python
+        values.
+
+        :param types: An iterable of string representations of the ABI types that
+            will be used for decoding e.g. ``('uint256', 'bytes[]', '(int,int)')``
+        :param data: The binary value to be decoded.
+
+        :returns: A tuple of equivalent python values for the ABI values
+            represented in ``data``.
+        """
+        warnings.warn(
+            "abi.decode_abi() is deprecated and will be removed in version 4.0.0 in "
+            "favor of abi.decode()",
+            category=DeprecationWarning,
+        )
+        return self.decode(types, data)
+
+    def decode(self, types, data):
+        if not is_bytes(data):
+            raise TypeError(
+                f"The `data` value must be of bytes type.  Got {type(data)}"
+            )
+
+        decoders = [self._registry.get_decoder(type_str) for type_str in types]
+
+        decoder = TupleDecoder(decoders=decoders)
+        stream = self.stream_class(data)
+
+        return decoder(stream)
+
+
+class ABICodec(ABIEncoder, ABIDecoder):
+    pass

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

@@ -0,0 +1,3 @@
+TT256 = 2**256
+TT256M1 = 2**256 - 1
+TT255 = 2**255