coinex-api 0.0.7__py3-none-any.whl → 0.0.9__py3-none-any.whl

coinex_api/ccxt/static_dependencies/ethereum/utils/__init__.py

@@ -1,115 +0,0 @@
-from importlib.metadata import (
-    version as __version,
-)
-
-# from .abi import (
-#     event_abi_to_log_topic,
-#     event_signature_to_log_topic,
-#     function_abi_to_4byte_selector,
-#     function_signature_to_4byte_selector,
-# )
-from .address import (
-    is_address,
-    is_binary_address,
-    is_canonical_address,
-    is_checksum_address,
-    is_checksum_formatted_address,
-    is_hex_address,
-    is_normalized_address,
-    is_same_address,
-    to_canonical_address,
-    to_checksum_address,
-    to_normalized_address,
-)
-from .applicators import (
-    apply_formatter_at_index,
-    apply_formatter_if,
-    apply_formatter_to_array,
-    apply_formatters_to_dict,
-    apply_formatters_to_sequence,
-    apply_key_map,
-    apply_one_of_formatters,
-    combine_argument_formatters,
-)
-from .conversions import (
-    hexstr_if_str,
-    text_if_str,
-    to_bytes,
-    to_hex,
-    to_int,
-    to_text,
-)
-from .currency import (
-    denoms,
-    from_wei,
-    to_wei,
-)
-from .decorators import (
-    combomethod,
-    replace_exceptions,
-)
-from .encoding import (
-    big_endian_to_int,
-    int_to_big_endian,
-)
-from .exceptions import (
-    ValidationError,
-)
-from .functional import (
-    apply_to_return_value,
-    flatten_return,
-    reversed_return,
-    sort_return,
-    to_dict,
-    to_list,
-    to_ordered_dict,
-    to_set,
-    to_tuple,
-)
-from .hexadecimal import (
-    add_0x_prefix,
-    decode_hex,
-    encode_hex,
-    is_0x_prefixed,
-    is_hex,
-    is_hexstr,
-    remove_0x_prefix,
-)
-from .humanize import (
-    humanize_bytes,
-    humanize_hash,
-    humanize_integer_sequence,
-    humanize_ipfs_uri,
-    humanize_seconds,
-    humanize_wei,
-)
-from .logging import (
-    DEBUG2_LEVEL_NUM,
-    ExtendedDebugLogger,
-    HasExtendedDebugLogger,
-    HasExtendedDebugLoggerMeta,
-    HasLogger,
-    HasLoggerMeta,
-    get_extended_debug_logger,
-    get_logger,
-    setup_DEBUG2_logging,
-)
-from .module_loading import (
-    import_string,
-)
-from .numeric import (
-    clamp,
-)
-from .types import (
-    is_boolean,
-    is_bytes,
-    is_dict,
-    is_integer,
-    is_list,
-    is_list_like,
-    is_null,
-    is_number,
-    is_string,
-    is_text,
-    is_tuple,
-)

coinex_api/ccxt/static_dependencies/ethereum/utils/abi.py

@@ -1,72 +0,0 @@
-from typing import (
-    Any,
-    Dict,
-)
-
-from .conversions import (
-    to_bytes
-)
-
-from ...keccak import (
-    SHA3 as keccak,
-)
-
-
-def collapse_if_tuple(abi: Dict[str, Any]) -> str:
-    """
-    Converts a tuple from a dict to a parenthesized list of its types.
-
-    >>> from eth_utils.abi import collapse_if_tuple
-    >>> collapse_if_tuple(
-    ...     {
-    ...         'components': [
-    ...             {'name': 'anAddress', 'type': 'address'},
-    ...             {'name': 'anInt', 'type': 'uint256'},
-    ...             {'name': 'someBytes', 'type': 'bytes'},
-    ...         ],
-    ...         'type': 'tuple',
-    ...     }
-    ... )
-    '(address,uint256,bytes)'
-    """
-    typ = abi["type"]
-    if not isinstance(typ, str):
-        raise TypeError(
-            f"The 'type' must be a string, but got {repr(typ)} of type {type(typ)}"
-        )
-    elif not typ.startswith("tuple"):
-        return typ
-
-    delimited = ",".join(collapse_if_tuple(c) for c in abi["components"])
-    # Whatever comes after "tuple" is the array dims. The ABI spec states that
-    # this will have the form "", "[]", or "[k]".
-    array_dim = typ[5:]
-    collapsed = f"({delimited}){array_dim}"
-
-    return collapsed
-
-
-def _abi_to_signature(abi: Dict[str, Any]) -> str:
-    fn_input_types = ",".join(
-        [collapse_if_tuple(abi_input) for abi_input in abi.get("inputs", [])]
-    )
-    function_signature = f"{abi['name']}({fn_input_types})"
-    return function_signature
-
-
-def function_signature_to_4byte_selector(event_signature: str) -> bytes:
-    return keccak(to_bytes(text=event_signature.replace(" ", "")))[:4]
-
-
-def function_abi_to_4byte_selector(function_abi: Dict[str, Any]) -> bytes:
-    function_signature = _abi_to_signature(function_abi)
-    return function_signature_to_4byte_selector(function_signature)
-
-
-def event_signature_to_log_topic(event_signature: str) -> bytes:
-    return keccak(to_bytes(text=event_signature.replace(" ", "")))
-
-
-def event_abi_to_log_topic(event_abi: Dict[str, Any]) -> bytes:
-    event_signature = _abi_to_signature(event_abi)
-    return event_signature_to_log_topic(event_signature)

coinex_api/ccxt/static_dependencies/ethereum/utils/address.py

@@ -1,171 +0,0 @@
-import re
-from typing import (
-    Any,
-    Union,
-    cast,
-)
-
-from ..typing import (
-    Address,
-    AnyAddress,
-    ChecksumAddress,
-    HexAddress,
-    HexStr,
-)
-
-from .conversions import (
-    hexstr_if_str,
-    to_hex,
-    to_bytes,
-)
-from ...keccak import (
-    SHA3 as keccak,
-)
-from .hexadecimal import (
-    add_0x_prefix,
-    decode_hex,
-    encode_hex,
-    remove_0x_prefix,
-)
-from .types import (
-    is_bytes,
-    is_text,
-)
-
-_HEX_ADDRESS_REGEXP = re.compile("(0x)?[0-9a-f]{40}", re.IGNORECASE | re.ASCII)
-
-
-def is_hex_address(value: Any) -> bool:
-    """
-    Checks if the given string of text type is an address in hexadecimal encoded form.
-    """
-    if not is_text(value):
-        return False
-    return _HEX_ADDRESS_REGEXP.fullmatch(value) is not None
-
-
-def is_binary_address(value: Any) -> bool:
-    """
-    Checks if the given string is an address in raw bytes form.
-    """
-    if not is_bytes(value):
-        return False
-    elif len(value) != 20:
-        return False
-    else:
-        return True
-
-
-def is_address(value: Any) -> bool:
-    """
-    Is the given string an address in any of the known formats?
-    """
-    if is_hex_address(value):
-        if _is_checksum_formatted(value):
-            return is_checksum_address(value)
-        return True
-
-    if is_binary_address(value):
-        return True
-
-    return False
-
-
-def to_normalized_address(value: Union[AnyAddress, str, bytes]) -> HexAddress:
-    """
-    Converts an address to its normalized hexadecimal representation.
-    """
-    try:
-        hex_address = hexstr_if_str(to_hex, value).lower()
-    except AttributeError:
-        raise TypeError(f"Value must be any string, instead got type {type(value)}")
-    if is_address(hex_address):
-        return HexAddress(HexStr(hex_address))
-    else:
-        raise ValueError(
-            f"Unknown format {repr(value)}, attempted to normalize to "
-            f"{repr(hex_address)}"
-        )
-
-
-def is_normalized_address(value: Any) -> bool:
-    """
-    Returns whether the provided value is an address in its normalized form.
-    """
-    if not is_address(value):
-        return False
-    else:
-        is_equal = value == to_normalized_address(value)
-        return cast(bool, is_equal)
-
-
-def to_canonical_address(address: Union[AnyAddress, str, bytes]) -> Address:
-    """
-    Convert a valid address to its canonical form (20-length bytes).
-    """
-    return Address(decode_hex(to_normalized_address(address)))
-
-
-def is_canonical_address(address: Any) -> bool:
-    """
-    Returns `True` if the `value` is an address in its canonical form.
-    """
-    if not is_bytes(address) or len(address) != 20:
-        return False
-    is_equal = address == to_canonical_address(address)
-    return cast(bool, is_equal)
-
-
-def is_same_address(left: AnyAddress, right: AnyAddress) -> bool:
-    """
-    Checks if both addresses are same or not.
-    """
-    if not is_address(left) or not is_address(right):
-        raise ValueError("Both values must be valid addresses")
-    else:
-        return bool(to_normalized_address(left) == to_normalized_address(right))
-
-
-def to_checksum_address(value: Union[AnyAddress, str, bytes]) -> ChecksumAddress:
-    """
-    Makes a checksum address given a supported format.
-    """
-    norm_address = to_normalized_address(value)
-    address_hash = encode_hex(keccak(to_bytes(text=remove_0x_prefix(HexStr(norm_address)))))
-
-    checksum_address = add_0x_prefix(
-        HexStr(
-            "".join(
-                (
-                    norm_address[i].upper()
-                    if int(address_hash[i], 16) > 7
-                    else norm_address[i]
-                )
-                for i in range(2, 42)
-            )
-        )
-    )
-    return ChecksumAddress(HexAddress(checksum_address))
-
-
-def is_checksum_address(value: Any) -> bool:
-    if not is_text(value):
-        return False
-
-    if not is_hex_address(value):
-        return False
-    is_equal = value == to_checksum_address(value)
-    return cast(bool, is_equal)
-
-
-def _is_checksum_formatted(value: Any) -> bool:
-    unprefixed_value = remove_0x_prefix(value)
-    return (
-        not unprefixed_value.islower()
-        and not unprefixed_value.isupper()
-        and not unprefixed_value.isnumeric()
-    )
-
-
-def is_checksum_formatted_address(value: Any) -> bool:
-    return is_hex_address(value) and _is_checksum_formatted(value)

coinex_api/ccxt/static_dependencies/ethereum/utils/applicators.py

@@ -1,151 +0,0 @@
-from typing import (
-    Any,
-    Callable,
-    Dict,
-    Generator,
-    List,
-    Tuple,
-)
-import warnings
-
-from .decorators import (
-    return_arg_type,
-)
-from .functional import (
-    to_dict,
-)
-from .toolz import (
-    compose,
-    curry,
-)
-
-Formatters = Callable[[List[Any]], List[Any]]
-
-
-@return_arg_type(2)
-def apply_formatter_at_index(
-    formatter: Callable[..., Any], at_index: int, value: List[Any]
-) -> Generator[List[Any], None, None]:
-    if at_index + 1 > len(value):
-        raise IndexError(
-            f"Not enough values in iterable to apply formatter. Got: {len(value)}. "
-            f"Need: {at_index + 1}"
-        )
-    for index, item in enumerate(value):
-        if index == at_index:
-            yield formatter(item)
-        else:
-            yield item
-
-
-def combine_argument_formatters(*formatters: List[Callable[..., Any]]) -> Formatters:
-    warnings.warn(
-        DeprecationWarning(
-            "combine_argument_formatters(formatter1, formatter2)([item1, item2])"
-            "has been deprecated and will be removed in a subsequent major version "
-            "release of the eth-utils library. Update your calls to use "
-            "apply_formatters_to_sequence([formatter1, formatter2], [item1, item2]) "
-            "instead."
-        ),
-        stacklevel=2,
-    )
-
-    _formatter_at_index = curry(apply_formatter_at_index)
-    return compose(  # type: ignore
-        *(
-            _formatter_at_index(formatter, index)
-            for index, formatter in enumerate(formatters)
-        )
-    )
-
-
-@return_arg_type(1)
-def apply_formatters_to_sequence(
-    formatters: List[Any], sequence: List[Any]
-) -> Generator[List[Any], None, None]:
-    if len(formatters) > len(sequence):
-        raise IndexError(
-            f"Too many formatters for sequence: {len(formatters)} formatters for "
-            f"{repr(sequence)}"
-        )
-    elif len(formatters) < len(sequence):
-        raise IndexError(
-            f"Too few formatters for sequence: {len(formatters)} formatters for "
-            f"{repr(sequence)}"
-        )
-    else:
-        for formatter, item in zip(formatters, sequence):
-            yield formatter(item)
-
-
-def apply_formatter_if(
-    condition: Callable[..., bool], formatter: Callable[..., Any], value: Any
-) -> Any:
-    if condition(value):
-        return formatter(value)
-    else:
-        return value
-
-
-@to_dict
-def apply_formatters_to_dict(
-    formatters: Dict[Any, Any], value: Dict[Any, Any]
-) -> Generator[Tuple[Any, Any], None, None]:
-    for key, item in value.items():
-        if key in formatters:
-            try:
-                yield key, formatters[key](item)
-            except ValueError as exc:
-                new_error_message = (
-                    f"Could not format invalid value {repr(item)} as field {repr(key)}"
-                )
-                raise ValueError(new_error_message) from exc
-            except TypeError as exc:
-                new_error_message = (
-                    f"Could not format invalid type {repr(item)} as field {repr(key)}"
-                )
-                raise TypeError(new_error_message) from exc
-        else:
-            yield key, item
-
-
-@return_arg_type(1)
-def apply_formatter_to_array(
-    formatter: Callable[..., Any], value: List[Any]
-) -> Generator[List[Any], None, None]:
-    for item in value:
-        yield formatter(item)
-
-
-def apply_one_of_formatters(
-    formatter_condition_pairs: Tuple[Tuple[Callable[..., Any], Callable[..., Any]]],
-    value: Any,
-) -> Any:
-    for condition, formatter in formatter_condition_pairs:
-        if condition(value):
-            return formatter(value)
-    else:
-        raise ValueError(
-            "The provided value did not satisfy any of the formatter conditions"
-        )
-
-
-@to_dict
-def apply_key_map(
-    key_mappings: Dict[Any, Any], value: Dict[Any, Any]
-) -> Generator[Tuple[Any, Any], None, None]:
-    key_conflicts = (
-        set(value.keys())
-        .difference(key_mappings.keys())
-        .intersection(v for k, v in key_mappings.items() if v in value)
-    )
-    if key_conflicts:
-        raise KeyError(
-            f"Could not apply key map due to conflicting key(s): {key_conflicts}"
-        )
-
-    for key, item in value.items():
-        if key in key_mappings:
-            yield key_mappings[key], item
-        else:
-            yield key, item

coinex_api/ccxt/static_dependencies/ethereum/utils/conversions.py

@@ -1,190 +0,0 @@
-from typing import (
-    Callable,
-    Optional,
-    TypeVar,
-    Union,
-    cast,
-)
-
-from ..typing import (
-    HexStr,
-    Primitives,
-)
-
-from .decorators import (
-    validate_conversion_arguments,
-)
-from .encoding import (
-    big_endian_to_int,
-    int_to_big_endian,
-)
-from .hexadecimal import (
-    add_0x_prefix,
-    decode_hex,
-    encode_hex,
-    is_hexstr,
-    remove_0x_prefix,
-)
-from .types import (
-    is_boolean,
-    is_integer,
-    is_string,
-)
-
-T = TypeVar("T")
-
-
-@validate_conversion_arguments
-def to_hex(
-    primitive: Optional[Primitives] = None,
-    hexstr: Optional[HexStr] = None,
-    text: Optional[str] = None,
-) -> HexStr:
-    """
-    Auto converts any supported value into its hex representation.
-    Trims leading zeros, as defined in:
-    https://github.com/ethereum/wiki/wiki/JSON-RPC#hex-value-encoding
-    """
-    if hexstr is not None:
-        return add_0x_prefix(HexStr(hexstr.lower()))
-
-    if text is not None:
-        return encode_hex(text.encode("utf-8"))
-
-    if is_boolean(primitive):
-        return HexStr("0x1") if primitive else HexStr("0x0")
-
-    if isinstance(primitive, (bytes, bytearray)):
-        return encode_hex(primitive)
-    elif is_string(primitive):
-        raise TypeError(
-            "Unsupported type: The primitive argument must be one of: bytes,"
-            "bytearray, int or bool and not str"
-        )
-
-    if is_integer(primitive):
-        return HexStr(hex(cast(int, primitive)))
-
-    raise TypeError(
-        f"Unsupported type: '{repr(type(primitive))}'. Must be one of: bool, str, "
-        "bytes, bytearray or int."
-    )
-
-
-@validate_conversion_arguments
-def to_int(
-    primitive: Optional[Primitives] = None,
-    hexstr: Optional[HexStr] = None,
-    text: Optional[str] = None,
-) -> int:
-    """
-    Converts value to its integer representation.
-    Values are converted this way:
-
-     * primitive:
-
-       * bytes, bytearrays: big-endian integer
-       * bool: True => 1, False => 0
-     * hexstr: interpret hex as integer
-     * text: interpret as string of digits, like '12' => 12
-    """
-    if hexstr is not None:
-        return int(hexstr, 16)
-    elif text is not None:
-        return int(text)
-    elif isinstance(primitive, (bytes, bytearray)):
-        return big_endian_to_int(primitive)
-    elif isinstance(primitive, str):
-        raise TypeError("Pass in strings with keyword hexstr or text")
-    elif isinstance(primitive, (int, bool)):
-        return int(primitive)
-    else:
-        raise TypeError(
-            "Invalid type. Expected one of int/bool/str/bytes/bytearray. Got "
-            f"{type(primitive)}"
-        )
-
-
-@validate_conversion_arguments
-def to_bytes(
-    primitive: Optional[Primitives] = None,
-    hexstr: Optional[HexStr] = None,
-    text: Optional[str] = None,
-) -> bytes:
-    if is_boolean(primitive):
-        return b"\x01" if primitive else b"\x00"
-    elif isinstance(primitive, bytearray):
-        return bytes(primitive)
-    elif isinstance(primitive, bytes):
-        return primitive
-    elif is_integer(primitive):
-        return to_bytes(hexstr=to_hex(primitive))
-    elif hexstr is not None:
-        if len(hexstr) % 2:
-            hexstr = cast(HexStr, "0x0" + remove_0x_prefix(hexstr))
-        return decode_hex(hexstr)
-    elif text is not None:
-        return text.encode("utf-8")
-    raise TypeError(
-        "expected a bool, int, byte or bytearray in first arg, "
-        "or keyword of hexstr or text"
-    )
-
-
-@validate_conversion_arguments
-def to_text(
-    primitive: Optional[Primitives] = None,
-    hexstr: Optional[HexStr] = None,
-    text: Optional[str] = None,
-) -> str:
-    if hexstr is not None:
-        return to_bytes(hexstr=hexstr).decode("utf-8")
-    elif text is not None:
-        return text
-    elif isinstance(primitive, str):
-        return to_text(hexstr=primitive)
-    elif isinstance(primitive, (bytes, bytearray)):
-        return primitive.decode("utf-8")
-    elif is_integer(primitive):
-        byte_encoding = int_to_big_endian(cast(int, primitive))
-        return to_text(byte_encoding)
-    raise TypeError("Expected an int, bytes, bytearray or hexstr.")
-
-
-def text_if_str(
-    to_type: Callable[..., T], text_or_primitive: Union[bytes, int, str]
-) -> T:
-    """
-    Convert to a type, assuming that strings can be only unicode text (not a hexstr).
-
-    :param to_type function: takes the arguments (primitive, hexstr=hexstr, text=text),
-        eg~ to_bytes, to_text, to_hex, to_int, etc
-    :param text_or_primitive bytes, str, int: value to convert
-    """
-    if isinstance(text_or_primitive, str):
-        return to_type(text=text_or_primitive)
-    else:
-        return to_type(text_or_primitive)
-
-
-def hexstr_if_str(
-    to_type: Callable[..., T], hexstr_or_primitive: Union[bytes, int, str]
-) -> T:
-    """
-    Convert to a type, assuming that strings can be only hexstr (not unicode text).
-
-    :param to_type function: takes the arguments (primitive, hexstr=hexstr, text=text),
-        eg~ to_bytes, to_text, to_hex, to_int, etc
-    :param hexstr_or_primitive bytes, str, int: value to convert
-    """
-    if isinstance(hexstr_or_primitive, str):
-        if remove_0x_prefix(HexStr(hexstr_or_primitive)) and not is_hexstr(
-            hexstr_or_primitive
-        ):
-            raise ValueError(
-                "when sending a str, it must be a hex string. "
-                f"Got: {repr(hexstr_or_primitive)}"
-            )
-        return to_type(hexstr=hexstr_or_primitive)
-    else:
-        return to_type(hexstr_or_primitive)