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

coinex/ccxt/static_dependencies/ethereum/utils/currency.py

@@ -0,0 +1,107 @@
+import decimal
+from decimal import (
+    localcontext,
+)
+from typing import (
+    Union,
+)
+
+from .types import (
+    is_integer,
+    is_string,
+)
+from .units import (
+    units,
+)
+
+
+class denoms:
+    wei = int(units["wei"])
+    kwei = int(units["kwei"])
+    babbage = int(units["babbage"])
+    femtoether = int(units["femtoether"])
+    mwei = int(units["mwei"])
+    lovelace = int(units["lovelace"])
+    picoether = int(units["picoether"])
+    gwei = int(units["gwei"])
+    shannon = int(units["shannon"])
+    nanoether = int(units["nanoether"])
+    nano = int(units["nano"])
+    szabo = int(units["szabo"])
+    microether = int(units["microether"])
+    micro = int(units["micro"])
+    finney = int(units["finney"])
+    milliether = int(units["milliether"])
+    milli = int(units["milli"])
+    ether = int(units["ether"])
+    kether = int(units["kether"])
+    grand = int(units["grand"])
+    mether = int(units["mether"])
+    gether = int(units["gether"])
+    tether = int(units["tether"])
+
+
+MIN_WEI = 0
+MAX_WEI = 2**256 - 1
+
+
+def from_wei(number: int, unit: str) -> Union[int, decimal.Decimal]:
+    """
+    Takes a number of wei and converts it to any other ether unit.
+    """
+    if unit.lower() not in units:
+        raise ValueError(f"Unknown unit. Must be one of {'/'.join(units.keys())}")
+
+    if number == 0:
+        return 0
+
+    if number < MIN_WEI or number > MAX_WEI:
+        raise ValueError("value must be between 1 and 2**256 - 1")
+
+    unit_value = units[unit.lower()]
+
+    with localcontext() as ctx:
+        ctx.prec = 999
+        d_number = decimal.Decimal(value=number, context=ctx)
+        result_value = d_number / unit_value
+
+    return result_value
+
+
+def to_wei(number: Union[int, float, str, decimal.Decimal], unit: str) -> int:
+    """
+    Takes a number of a unit and converts it to wei.
+    """
+    if unit.lower() not in units:
+        raise ValueError(f"Unknown unit. Must be one of {'/'.join(units.keys())}")
+
+    if is_integer(number) or is_string(number):
+        d_number = decimal.Decimal(value=number)
+    elif isinstance(number, float):
+        d_number = decimal.Decimal(value=str(number))
+    elif isinstance(number, decimal.Decimal):
+        d_number = number
+    else:
+        raise TypeError("Unsupported type. Must be one of integer, float, or string")
+
+    s_number = str(number)
+    unit_value = units[unit.lower()]
+
+    if d_number == decimal.Decimal(0):
+        return 0
+
+    if d_number < 1 and "." in s_number:
+        with localcontext() as ctx:
+            multiplier = len(s_number) - s_number.index(".") - 1
+            ctx.prec = multiplier
+            d_number = decimal.Decimal(value=number, context=ctx) * 10**multiplier
+        unit_value /= 10**multiplier
+
+    with localcontext() as ctx:
+        ctx.prec = 999
+        result_value = decimal.Decimal(value=d_number, context=ctx) * unit_value
+
+    if result_value < MIN_WEI or result_value > MAX_WEI:
+        raise ValueError("Resulting wei value must be between 1 and 2**256 - 1")
+
+    return int(result_value)

coinex/ccxt/static_dependencies/ethereum/utils/curried/__init__.py

@@ -0,0 +1,269 @@
+from typing import (
+    Any,
+    Callable,
+    Dict,
+    Generator,
+    Optional,
+    Sequence,
+    Tuple,
+    TypeVar,
+    Union,
+    overload,
+)
+
+from .. import (
+    ExtendedDebugLogger,
+    HasExtendedDebugLogger,
+    HasExtendedDebugLoggerMeta,
+    HasLogger,
+    HasLoggerMeta,
+    ValidationError,
+    add_0x_prefix,
+    apply_formatter_at_index,
+    apply_formatter_if as non_curried_apply_formatter_if,
+    apply_formatter_to_array,
+    apply_formatters_to_dict as non_curried_apply_formatters_to_dict,
+    apply_formatters_to_sequence,
+    apply_key_map,
+    apply_one_of_formatters as non_curried_apply_one_of_formatters,
+    apply_to_return_value,
+    big_endian_to_int,
+    clamp,
+    combine_argument_formatters,
+    combomethod,
+    decode_hex,
+    denoms,
+    encode_hex,
+    # event_abi_to_log_topic,
+    # event_signature_to_log_topic,
+    flatten_return,
+    from_wei,
+    # function_abi_to_4byte_selector,
+    # function_signature_to_4byte_selector,
+    get_extended_debug_logger,
+    get_logger,
+    hexstr_if_str as non_curried_hexstr_if_str,
+    humanize_bytes,
+    humanize_hash,
+    humanize_integer_sequence,
+    humanize_ipfs_uri,
+    humanize_seconds,
+    humanize_wei,
+    import_string,
+    int_to_big_endian,
+    is_0x_prefixed,
+    is_address,
+    is_binary_address,
+    is_boolean,
+    is_bytes,
+    is_canonical_address,
+    is_checksum_address,
+    is_checksum_formatted_address,
+    is_dict,
+    is_hex,
+    is_hex_address,
+    is_hexstr,
+    is_integer,
+    is_list,
+    is_list_like,
+    is_normalized_address,
+    is_null,
+    is_number,
+    is_same_address,
+    is_string,
+    is_text,
+    is_tuple,
+    # keccak,
+    remove_0x_prefix,
+    replace_exceptions,
+    reversed_return,
+    setup_DEBUG2_logging,
+    sort_return,
+    text_if_str as non_curried_text_if_str,
+    to_bytes,
+    to_canonical_address,
+    to_checksum_address,
+    to_dict,
+    to_hex,
+    to_int,
+    to_list,
+    to_normalized_address,
+    to_ordered_dict,
+    to_set,
+    to_text,
+    to_tuple,
+    to_wei,
+)
+from ..toolz import (
+    curry,
+)
+
+TReturn = TypeVar("TReturn")
+TValue = TypeVar("TValue")
+
+
+@overload
+def apply_formatter_if(
+    condition: Callable[..., bool]
+) -> Callable[[Callable[..., TReturn]], Callable[[TValue], Union[TReturn, TValue]]]:
+    pass
+
+
+@overload
+def apply_formatter_if(
+    condition: Callable[..., bool], formatter: Callable[..., TReturn]
+) -> Callable[[TValue], Union[TReturn, TValue]]:
+    pass
+
+
+@overload
+def apply_formatter_if(
+    condition: Callable[..., bool], formatter: Callable[..., TReturn], value: TValue
+) -> Union[TReturn, TValue]:
+    pass
+
+
+# This is just a stub to appease mypy, it gets overwritten later
+def apply_formatter_if(  # type: ignore
+    condition: Callable[..., bool],
+    formatter: Optional[Callable[..., TReturn]] = None,
+    value: Optional[TValue] = None,
+) -> Union[
+    Callable[[Callable[..., TReturn]], Callable[[TValue], Union[TReturn, TValue]]],
+    Callable[[TValue], Union[TReturn, TValue]],
+    TReturn,
+    TValue,
+]:
+    pass
+
+
+@overload
+def apply_one_of_formatters(
+    formatter_condition_pairs: Sequence[
+        Tuple[Callable[..., bool], Callable[..., TReturn]]
+    ]
+) -> Callable[[TValue], TReturn]:
+    ...
+
+
+@overload
+def apply_one_of_formatters(
+    formatter_condition_pairs: Sequence[
+        Tuple[Callable[..., bool], Callable[..., TReturn]]
+    ],
+    value: TValue,
+) -> TReturn:
+    ...
+
+
+# This is just a stub to appease mypy, it gets overwritten later
+def apply_one_of_formatters(  # type: ignore
+    formatter_condition_pairs: Sequence[
+        Tuple[Callable[..., bool], Callable[..., TReturn]]
+    ],
+    value: Optional[TValue] = None,
+) -> TReturn:
+    ...
+
+
+@overload
+def hexstr_if_str(
+    to_type: Callable[..., TReturn]
+) -> Callable[[Union[bytes, int, str]], TReturn]:
+    ...
+
+
+@overload
+def hexstr_if_str(
+    to_type: Callable[..., TReturn], to_format: Union[bytes, int, str]
+) -> TReturn:
+    ...
+
+
+# This is just a stub to appease mypy, it gets overwritten later
+def hexstr_if_str(  # type: ignore
+    to_type: Callable[..., TReturn], to_format: Optional[Union[bytes, int, str]] = None
+) -> TReturn:
+    ...
+
+
+@overload
+def text_if_str(
+    to_type: Callable[..., TReturn]
+) -> Callable[[Union[bytes, int, str]], TReturn]:
+    ...
+
+
+@overload
+def text_if_str(
+    to_type: Callable[..., TReturn], text_or_primitive: Union[bytes, int, str]
+) -> TReturn:
+    ...
+
+
+# This is just a stub to appease mypy, it gets overwritten later
+def text_if_str(  # type: ignore
+    to_type: Callable[..., TReturn],
+    text_or_primitive: Optional[Union[bytes, int, str]] = None,
+) -> TReturn:
+    ...
+
+
+@overload
+def apply_formatters_to_dict(
+    formatters: Dict[Any, Any]
+) -> Callable[[Dict[Any, Any]], TReturn]:
+    ...
+
+
+@overload
+def apply_formatters_to_dict(
+    formatters: Dict[Any, Any], value: Dict[Any, Any]
+) -> Dict[Any, Any]:
+    ...
+
+
+# This is just a stub to appease mypy, it gets overwritten later
+def apply_formatters_to_dict(  # type: ignore
+    formatters: Dict[Any, Any], value: Optional[Dict[Any, Any]] = None
+) -> Dict[Any, Any]:
+    ...
+
+
+apply_formatter_at_index = curry(apply_formatter_at_index)
+apply_formatter_if = curry(non_curried_apply_formatter_if)  # noqa: F811
+apply_formatter_to_array = curry(apply_formatter_to_array)
+apply_formatters_to_dict = curry(non_curried_apply_formatters_to_dict)  # noqa: F811
+apply_formatters_to_sequence = curry(apply_formatters_to_sequence)
+apply_key_map = curry(apply_key_map)
+apply_one_of_formatters = curry(non_curried_apply_one_of_formatters)  # noqa: F811
+from_wei = curry(from_wei)
+get_logger = curry(get_logger)
+hexstr_if_str = curry(non_curried_hexstr_if_str)  # noqa: F811
+is_same_address = curry(is_same_address)
+text_if_str = curry(non_curried_text_if_str)  # noqa: F811
+to_wei = curry(to_wei)
+clamp = curry(clamp)
+
+# Delete any methods and classes that are not intended to be importable from
+# `eth_utils.curried`. We do this approach instead of __all__ because this approach
+# actually prevents importing the wrong thing, while __all__ only affects
+# `from eth_utils.curried import *`
+del Any
+del Callable
+del Dict
+del Generator
+del Optional
+del Sequence
+del TReturn
+del TValue
+del Tuple
+del TypeVar
+del Union
+del curry
+del non_curried_apply_formatter_if
+del non_curried_apply_one_of_formatters
+del non_curried_apply_formatters_to_dict
+del non_curried_hexstr_if_str
+del non_curried_text_if_str
+del overload

coinex/ccxt/static_dependencies/ethereum/utils/debug.py

@@ -0,0 +1,20 @@
+import platform
+import subprocess
+import sys
+
+
+def pip_freeze() -> str:
+    result = subprocess.run("python -m pip freeze".split(), stdout=subprocess.PIPE)
+    return f"python -m pip freeze result:\n{result.stdout.decode()}"
+
+
+def python_version() -> str:
+    return f"Python version:\n{sys.version}"
+
+
+def platform_info() -> str:
+    return f"Operating System: {platform.platform()}"
+
+
+def get_environment_summary() -> str:
+    return "\n\n".join([python_version(), platform_info(), pip_freeze()])

coinex/ccxt/static_dependencies/ethereum/utils/decorators.py

@@ -0,0 +1,132 @@
+import functools
+import itertools
+from typing import (
+    Any,
+    Callable,
+    Dict,
+    Optional,
+    Type,
+    TypeVar,
+)
+
+from .types import (
+    is_text,
+)
+
+T = TypeVar("T")
+
+
+class combomethod:
+    def __init__(self, method: Callable[..., Any]) -> None:
+        self.method = method
+
+    def __get__(
+        self, obj: Optional[T] = None, objtype: Optional[Type[T]] = None
+    ) -> Callable[..., Any]:
+        @functools.wraps(self.method)
+        def _wrapper(*args: Any, **kwargs: Any) -> Any:
+            if obj is not None:
+                return self.method(obj, *args, **kwargs)
+            else:
+                return self.method(objtype, *args, **kwargs)
+
+        return _wrapper
+
+
+def _has_one_val(*args: T, **kwargs: T) -> bool:
+    vals = itertools.chain(args, kwargs.values())
+    not_nones = list(filter(lambda val: val is not None, vals))
+    return len(not_nones) == 1
+
+
+def _assert_one_val(*args: T, **kwargs: T) -> None:
+    if not _has_one_val(*args, **kwargs):
+        raise TypeError(
+            "Exactly one of the passed values can be specified. "
+            f"Instead, values were: {repr(args)}, {repr(kwargs)}"
+        )
+
+
+def _hexstr_or_text_kwarg_is_text_type(**kwargs: T) -> bool:
+    value = kwargs["hexstr"] if "hexstr" in kwargs else kwargs["text"]
+    return is_text(value)
+
+
+def _assert_hexstr_or_text_kwarg_is_text_type(**kwargs: T) -> None:
+    if not _hexstr_or_text_kwarg_is_text_type(**kwargs):
+        raise TypeError(
+            "Arguments passed as hexstr or text must be of text type. "
+            f"Instead, value was: {(repr(next(iter(list(kwargs.values())))))}"
+        )
+
+
+def _validate_supported_kwarg(kwargs: Any) -> None:
+    if next(iter(kwargs)) not in ["primitive", "hexstr", "text"]:
+        raise TypeError(
+            "Kwarg must be 'primitive', 'hexstr', or 'text'. "
+            f"Instead, kwarg was: {repr((next(iter(kwargs))))}"
+        )
+
+
+def validate_conversion_arguments(to_wrap: Callable[..., T]) -> Callable[..., T]:
+    """
+    Validates arguments for conversion functions.
+    - Only a single argument is present
+    - Kwarg must be 'primitive' 'hexstr' or 'text'
+    - If it is 'hexstr' or 'text' that it is a text type
+    """
+
+    @functools.wraps(to_wrap)
+    def wrapper(*args: Any, **kwargs: Any) -> T:
+        _assert_one_val(*args, **kwargs)
+        if kwargs:
+            _validate_supported_kwarg(kwargs)
+
+        if len(args) == 0 and "primitive" not in kwargs:
+            _assert_hexstr_or_text_kwarg_is_text_type(**kwargs)
+        return to_wrap(*args, **kwargs)
+
+    return wrapper
+
+
+def return_arg_type(at_position: int) -> Callable[..., Callable[..., T]]:
+    """
+    Wrap the return value with the result of `type(args[at_position])`.
+    """
+
+    def decorator(to_wrap: Callable[..., Any]) -> Callable[..., T]:
+        @functools.wraps(to_wrap)
+        def wrapper(*args: Any, **kwargs: Any) -> T:  # type: ignore
+            result = to_wrap(*args, **kwargs)
+            ReturnType = type(args[at_position])
+            return ReturnType(result)  # type: ignore
+
+        return wrapper
+
+    return decorator
+
+
+def replace_exceptions(
+    old_to_new_exceptions: Dict[Type[BaseException], Type[BaseException]]
+) -> Callable[[Callable[..., T]], Callable[..., T]]:
+    """
+    Replaces old exceptions with new exceptions to be raised in their place.
+    """
+    old_exceptions = tuple(old_to_new_exceptions.keys())
+
+    def decorator(to_wrap: Callable[..., T]) -> Callable[..., T]:
+        @functools.wraps(to_wrap)
+        def wrapped(*args: Any, **kwargs: Any) -> T:
+            try:
+                return to_wrap(*args, **kwargs)
+            except old_exceptions as err:
+                try:
+                    raise old_to_new_exceptions[type(err)](err) from err
+                except KeyError:
+                    raise TypeError(
+                        f"could not look up new exception to use for {repr(err)}"
+                    ) from err
+
+        return wrapped
+
+    return decorator

coinex/ccxt/static_dependencies/ethereum/utils/encoding.py

@@ -0,0 +1,6 @@
+def int_to_big_endian(value: int) -> bytes:
+    return value.to_bytes((value.bit_length() + 7) // 8 or 1, "big")
+
+
+def big_endian_to_int(value: bytes) -> int:
+    return int.from_bytes(value, "big")

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

@@ -0,0 +1,4 @@
+class ValidationError(Exception):
+    """
+    Raised when something does not pass a validation check.
+    """

coinex/ccxt/static_dependencies/ethereum/utils/functional.py

@@ -0,0 +1,75 @@
+import collections
+import functools
+import itertools
+from typing import (  # noqa: F401
+    Any,
+    Callable,
+    Dict,
+    Iterable,
+    List,
+    Mapping,
+    Set,
+    Tuple,
+    TypeVar,
+    Union,
+)
+
+from .toolz import (
+    compose as _compose,
+)
+
+T = TypeVar("T")
+
+
+def identity(value: T) -> T:
+    return value
+
+
+TGIn = TypeVar("TGIn")
+TGOut = TypeVar("TGOut")
+TFOut = TypeVar("TFOut")
+
+
+def combine(
+    f: Callable[[TGOut], TFOut], g: Callable[[TGIn], TGOut]
+) -> Callable[[TGIn], TFOut]:
+    return lambda x: f(g(x))
+
+
+def apply_to_return_value(
+    callback: Callable[..., T]
+) -> Callable[..., Callable[..., T]]:
+    def outer(fn: Callable[..., T]) -> Callable[..., T]:
+        # We would need to type annotate *args and **kwargs but doing so segfaults
+        # the PyPy builds. We ignore instead.
+        @functools.wraps(fn)
+        def inner(*args, **kwargs) -> T:  # type: ignore
+            return callback(fn(*args, **kwargs))
+
+        return inner
+
+    return outer
+
+
+TVal = TypeVar("TVal")
+TKey = TypeVar("TKey")
+to_tuple = apply_to_return_value(
+    tuple
+)  # type: Callable[[Callable[..., Iterable[TVal]]], Callable[..., Tuple[TVal, ...]]]  # noqa: E501
+to_list = apply_to_return_value(
+    list
+)  # type: Callable[[Callable[..., Iterable[TVal]]], Callable[..., List[TVal]]]  # noqa: E501
+to_set = apply_to_return_value(
+    set
+)  # type: Callable[[Callable[..., Iterable[TVal]]], Callable[..., Set[TVal]]]  # noqa: E501
+to_dict = apply_to_return_value(
+    dict
+)  # type: Callable[[Callable[..., Iterable[Union[Mapping[TKey, TVal], Tuple[TKey, TVal]]]]], Callable[..., Dict[TKey, TVal]]]  # noqa: E501
+to_ordered_dict = apply_to_return_value(
+    collections.OrderedDict
+)  # type: Callable[[Callable[..., Iterable[Union[Mapping[TKey, TVal], Tuple[TKey, TVal]]]]], Callable[..., collections.OrderedDict[TKey, TVal]]]  # noqa: E501
+sort_return = _compose(to_tuple, apply_to_return_value(sorted))
+flatten_return = _compose(
+    to_tuple, apply_to_return_value(itertools.chain.from_iterable)
+)
+reversed_return = _compose(to_tuple, apply_to_return_value(reversed), to_tuple)

coinex/ccxt/static_dependencies/ethereum/utils/hexadecimal.py

@@ -0,0 +1,74 @@
+# String encodings and numeric representations
+
+import binascii
+import re
+from typing import (
+    Any,
+    AnyStr,
+)
+
+from ..typing import (
+    HexStr,
+)
+
+from .types import (
+    is_string,
+    is_text,
+)
+
+_HEX_REGEXP = re.compile("(0[xX])?[0-9a-fA-F]*")
+
+
+def decode_hex(value: str) -> bytes:
+    if not is_text(value):
+        raise TypeError("Value must be an instance of str")
+    non_prefixed = remove_0x_prefix(HexStr(value))
+    # unhexlify will only accept bytes type someday
+    ascii_hex = non_prefixed.encode("ascii")
+    return binascii.unhexlify(ascii_hex)
+
+
+def encode_hex(value: AnyStr) -> HexStr:
+    if not is_string(value):
+        raise TypeError("Value must be an instance of str or unicode")
+    elif isinstance(value, (bytes, bytearray)):
+        ascii_bytes = value
+    else:
+        ascii_bytes = value.encode("ascii")
+
+    binary_hex = binascii.hexlify(ascii_bytes)
+    return add_0x_prefix(HexStr(binary_hex.decode("ascii")))
+
+
+def is_0x_prefixed(value: str) -> bool:
+    if not is_text(value):
+        raise TypeError(
+            f"is_0x_prefixed requires text typed arguments. Got: {repr(value)}"
+        )
+    return value.startswith(("0x", "0X"))
+
+
+def remove_0x_prefix(value: HexStr) -> HexStr:
+    if is_0x_prefixed(value):
+        return HexStr(value[2:])
+    return value
+
+
+def add_0x_prefix(value: HexStr) -> HexStr:
+    if is_0x_prefixed(value):
+        return value
+    return HexStr("0x" + value)
+
+
+def is_hexstr(value: Any) -> bool:
+    if not is_text(value) or not value:
+        return False
+    return _HEX_REGEXP.fullmatch(value) is not None
+
+
+def is_hex(value: Any) -> bool:
+    if not is_text(value):
+        raise TypeError(f"is_hex requires text typed arguments. Got: {repr(value)}")
+    if not value:
+        return False
+    return _HEX_REGEXP.fullmatch(value) is not None