coinex-api 0.0.6__py3-none-any.whl → 0.0.8__py3-none-any.whl

coinex_api/ccxt/static_dependencies/ethereum/abi/tools/_strategies.py

@@ -1,230 +0,0 @@
-from typing import (
-    Callable,
-    Union,
-)
-
-from ...typing.abi import (
-    TypeStr,
-)
-from ..utils import (
-    to_checksum_address,
-)
-from hypothesis import (
-    strategies as st,
-)
-
-from ..grammar import (
-    ABIType,
-    normalize,
-    parse,
-)
-from ..registry import (
-    BaseEquals,
-    BaseRegistry,
-    Lookup,
-    PredicateMapping,
-    has_arrlist,
-    is_base_tuple,
-)
-from ..utils.numeric import (
-    scale_places,
-)
-
-StrategyFactory = Callable[[ABIType, "StrategyRegistry"], st.SearchStrategy]
-StrategyRegistration = Union[st.SearchStrategy, StrategyFactory]
-
-
-class StrategyRegistry(BaseRegistry):
-    def __init__(self):
-        self._strategies = PredicateMapping("strategy registry")
-
-    def register_strategy(
-        self, lookup: Lookup, registration: StrategyRegistration, label: str = None
-    ) -> None:
-        self._register(self._strategies, lookup, registration, label=label)
-
-    def unregister_strategy(self, lookup_or_label: Lookup) -> None:
-        self._unregister(self._strategies, lookup_or_label)
-
-    def get_strategy(self, type_str: TypeStr) -> st.SearchStrategy:
-        """
-        Returns a hypothesis strategy for the given ABI type.
-
-        :param type_str: The canonical string representation of the ABI type
-            for which a hypothesis strategy should be returned.
-
-        :returns: A hypothesis strategy for generating Python values that are
-            encodable as values of the given ABI type.
-        """
-        registration = self._get_registration(self._strategies, type_str)
-
-        if isinstance(registration, st.SearchStrategy):
-            # If a hypothesis strategy was registered, just return it
-            return registration
-        else:
-            # Otherwise, assume the factory is a callable.  Call it with the abi
-            # type to get an appropriate hypothesis strategy.
-            normalized_type_str = normalize(type_str)
-            abi_type = parse(normalized_type_str)
-            strategy = registration(abi_type, self)
-
-            return strategy
-
-
-def get_uint_strategy(
-    abi_type: ABIType, registry: StrategyRegistry
-) -> st.SearchStrategy:
-    bits = abi_type.sub
-
-    return st.integers(
-        min_value=0,
-        max_value=2**bits - 1,
-    )
-
-
-def get_int_strategy(
-    abi_type: ABIType, registry: StrategyRegistry
-) -> st.SearchStrategy:
-    bits = abi_type.sub
-
-    return st.integers(
-        min_value=-(2 ** (bits - 1)),
-        max_value=2 ** (bits - 1) - 1,
-    )
-
-
-address_strategy = st.binary(min_size=20, max_size=20).map(to_checksum_address)
-bool_strategy = st.booleans()
-
-
-def get_ufixed_strategy(
-    abi_type: ABIType, registry: StrategyRegistry
-) -> st.SearchStrategy:
-    bits, places = abi_type.sub
-
-    return st.decimals(
-        min_value=0,
-        max_value=2**bits - 1,
-        places=0,
-    ).map(scale_places(places))
-
-
-def get_fixed_strategy(
-    abi_type: ABIType, registry: StrategyRegistry
-) -> st.SearchStrategy:
-    bits, places = abi_type.sub
-
-    return st.decimals(
-        min_value=-(2 ** (bits - 1)),
-        max_value=2 ** (bits - 1) - 1,
-        places=0,
-    ).map(scale_places(places))
-
-
-def get_bytes_strategy(
-    abi_type: ABIType, registry: StrategyRegistry
-) -> st.SearchStrategy:
-    num_bytes = abi_type.sub
-
-    return st.binary(
-        min_size=num_bytes,
-        max_size=num_bytes,
-    )
-
-
-bytes_strategy = st.binary(min_size=0, max_size=4096)
-string_strategy = st.text()
-
-
-def get_array_strategy(
-    abi_type: ABIType, registry: StrategyRegistry
-) -> st.SearchStrategy:
-    item_type = abi_type.item_type
-    item_type_str = item_type.to_type_str()
-    item_strategy = registry.get_strategy(item_type_str)
-
-    last_dim = abi_type.arrlist[-1]
-    if len(last_dim) == 0:
-        # Is dynamic list.  Don't restrict length.
-        return st.lists(item_strategy)
-    else:
-        # Is static list.  Restrict length.
-        dim_size = last_dim[0]
-        return st.lists(item_strategy, min_size=dim_size, max_size=dim_size)
-
-
-def get_tuple_strategy(
-    abi_type: ABIType, registry: StrategyRegistry
-) -> st.SearchStrategy:
-    component_strategies = [
-        registry.get_strategy(comp_abi_type.to_type_str())
-        for comp_abi_type in abi_type.components
-    ]
-
-    return st.tuples(*component_strategies)
-
-
-strategy_registry = StrategyRegistry()
-
-strategy_registry.register_strategy(
-    BaseEquals("uint"),
-    get_uint_strategy,
-    label="uint",
-)
-strategy_registry.register_strategy(
-    BaseEquals("int"),
-    get_int_strategy,
-    label="int",
-)
-strategy_registry.register_strategy(
-    BaseEquals("address", with_sub=False),
-    address_strategy,
-    label="address",
-)
-strategy_registry.register_strategy(
-    BaseEquals("bool", with_sub=False),
-    bool_strategy,
-    label="bool",
-)
-strategy_registry.register_strategy(
-    BaseEquals("ufixed"),
-    get_ufixed_strategy,
-    label="ufixed",
-)
-strategy_registry.register_strategy(
-    BaseEquals("fixed"),
-    get_fixed_strategy,
-    label="fixed",
-)
-strategy_registry.register_strategy(
-    BaseEquals("bytes", with_sub=True),
-    get_bytes_strategy,
-    label="bytes<M>",
-)
-strategy_registry.register_strategy(
-    BaseEquals("bytes", with_sub=False),
-    bytes_strategy,
-    label="bytes",
-)
-strategy_registry.register_strategy(
-    BaseEquals("function", with_sub=False),
-    get_bytes_strategy,
-    label="function",
-)
-strategy_registry.register_strategy(
-    BaseEquals("string", with_sub=False),
-    string_strategy,
-    label="string",
-)
-strategy_registry.register_strategy(
-    has_arrlist,
-    get_array_strategy,
-    label="has_arrlist",
-)
-strategy_registry.register_strategy(
-    is_base_tuple,
-    get_tuple_strategy,
-    label="is_base_tuple",
-)
-
-get_abi_strategy = strategy_registry.get_strategy

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

@@ -1,83 +0,0 @@
-import decimal
-from typing import (
-    Callable,
-    Tuple,
-)
-
-ABI_DECIMAL_PREC = 999
-
-abi_decimal_context = decimal.Context(prec=ABI_DECIMAL_PREC)
-
-ZERO = decimal.Decimal(0)
-TEN = decimal.Decimal(10)
-
-
-def ceil32(x: int) -> int:
-    return x if x % 32 == 0 else x + 32 - (x % 32)
-
-
-def compute_unsigned_integer_bounds(num_bits: int) -> Tuple[int, int]:
-    return (
-        0,
-        2**num_bits - 1,
-    )
-
-
-def compute_signed_integer_bounds(num_bits: int) -> Tuple[int, int]:
-    return (
-        -1 * 2 ** (num_bits - 1),
-        2 ** (num_bits - 1) - 1,
-    )
-
-
-def compute_unsigned_fixed_bounds(
-    num_bits: int,
-    frac_places: int,
-) -> Tuple[decimal.Decimal, decimal.Decimal]:
-    int_upper = compute_unsigned_integer_bounds(num_bits)[1]
-
-    with decimal.localcontext(abi_decimal_context):
-        upper = decimal.Decimal(int_upper) * TEN**-frac_places
-
-    return ZERO, upper
-
-
-def compute_signed_fixed_bounds(
-    num_bits: int,
-    frac_places: int,
-) -> Tuple[decimal.Decimal, decimal.Decimal]:
-    int_lower, int_upper = compute_signed_integer_bounds(num_bits)
-
-    with decimal.localcontext(abi_decimal_context):
-        exp = TEN**-frac_places
-        lower = decimal.Decimal(int_lower) * exp
-        upper = decimal.Decimal(int_upper) * exp
-
-    return lower, upper
-
-
-def scale_places(places: int) -> Callable[[decimal.Decimal], decimal.Decimal]:
-    """
-    Returns a function that shifts the decimal point of decimal values to the
-    right by ``places`` places.
-    """
-    if not isinstance(places, int):
-        raise ValueError(
-            f"Argument `places` must be int.  Got value {places} "
-            f"of type {type(places)}.",
-        )
-
-    with decimal.localcontext(abi_decimal_context):
-        scaling_factor = TEN**-places
-
-    def f(x: decimal.Decimal) -> decimal.Decimal:
-        with decimal.localcontext(abi_decimal_context):
-            return x * scaling_factor
-
-    places_repr = f"Eneg{places}" if places > 0 else f"Epos{-places}"
-    func_name = f"scale_by_{places_repr}"
-
-    f.__name__ = func_name
-    f.__qualname__ = func_name
-
-    return f

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

@@ -1,27 +0,0 @@
-from ...utils.toolz import (
-    curry,
-)
-
-
-@curry
-def zpad(value: bytes, length: int) -> bytes:
-    return value.rjust(length, b"\x00")
-
-
-zpad32 = zpad(length=32)
-
-
-@curry
-def zpad_right(value: bytes, length: int) -> bytes:
-    return value.ljust(length, b"\x00")
-
-
-zpad32_right = zpad_right(length=32)
-
-
-@curry
-def fpad(value: bytes, length: int) -> bytes:
-    return value.rjust(length, b"\xff")
-
-
-fpad32 = fpad(length=32)

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

@@ -1,19 +0,0 @@
-from typing import (
-    Any,
-)
-
-
-def abbr(value: Any, limit: int = 79) -> str:
-    """
-    Converts a value into its string representation and abbreviates that
-    representation based on the given length `limit` if necessary.
-    """
-    rep = repr(value)
-
-    if len(rep) > limit:
-        if limit < 3:
-            raise ValueError("Abbreviation limit may not be less than 3")
-
-        rep = rep[: limit - 3] + "..."
-
-    return rep

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

@@ -1,3 +0,0 @@
-from .messages import *
-
-__all__ = ["messages"]

coinex_api/ccxt/static_dependencies/ethereum/account/encode_typed_data/__init__.py

@@ -1,4 +0,0 @@
-from .encoding_and_hashing import (
-    hash_domain,
-    hash_eip712_message,
-)

coinex_api/ccxt/static_dependencies/ethereum/account/encode_typed_data/encoding_and_hashing.py

@@ -1,239 +0,0 @@
-from typing import (
-    Any,
-    Dict,
-    List,
-    Tuple,
-    Union,
-)
-
-from ...abi import (
-    encode,
-)
-from ....keccak import (
-    SHA3 as keccak
-)
-from ...utils import (
-    to_bytes,
-    to_int,
-)
-
-from .helpers import (
-    EIP712_SOLIDITY_TYPES,
-    is_0x_prefixed_hexstr,
-    is_array_type,
-    parse_core_array_type,
-    parse_parent_array_type,
-)
-
-
-def get_primary_type(types: Dict[str, List[Dict[str, str]]]) -> str:
-    custom_types = set(types.keys())
-    custom_types_that_are_deps = set()
-
-    for type_ in custom_types:
-        type_fields = types[type_]
-        for field in type_fields:
-            parsed_type = parse_core_array_type(field["type"])
-            if parsed_type in custom_types and parsed_type != type_:
-                custom_types_that_are_deps.add(parsed_type)
-
-    primary_type = list(custom_types.difference(custom_types_that_are_deps))
-    if len(primary_type) == 1:
-        return primary_type[0]
-    else:
-        raise ValueError("Unable to determine primary type")
-
-
-def encode_field(
-    types: Dict[str, List[Dict[str, str]]],
-    name: str,
-    type_: str,
-    value: Any,
-) -> Tuple[str, Union[int, bytes]]:
-    if type_ in types.keys():
-        # type is a custom type
-        if value is None:
-            return ("bytes32", b"\x00" * 32)
-        else:
-            return ("bytes32", keccak(encode_data(type_, types, value)))
-
-    elif type_ in ["string", "bytes"] and value is None:
-        return ("bytes32", b"")
-
-    # None is allowed only for custom and dynamic types
-    elif value is None:
-        raise ValueError(f"Missing value for field `{name}` of type `{type_}`")
-
-    elif is_array_type(type_):
-        # handle array type with non-array value
-        if not isinstance(value, list):
-            raise ValueError(
-                f"Invalid value for field `{name}` of type `{type_}`: "
-                f"expected array, got `{value}` of type `{type(value)}`"
-            )
-
-        parsed_type = parse_parent_array_type(type_)
-        type_value_pairs = [
-            encode_field(types, name, parsed_type, item) for item in value
-        ]
-        if not type_value_pairs:
-            # the keccak hash of `encode((), ())`
-            return (
-                "bytes32",
-                b"\xc5\xd2F\x01\x86\xf7#<\x92~}\xb2\xdc\xc7\x03\xc0\xe5\x00\xb6S\xca\x82';{\xfa\xd8\x04]\x85\xa4p",  # noqa: E501
-            )
-
-        data_types, data_hashes = zip(*type_value_pairs)
-        return ("bytes32", keccak(encode(data_types, data_hashes)))
-
-    elif type_ == "bool":
-        return (type_, bool(value))
-
-    # all bytes types allow hexstr and str values
-    elif type_.startswith("bytes"):
-        if not isinstance(value, bytes):
-            if is_0x_prefixed_hexstr(value):
-                value = to_bytes(hexstr=value)
-            elif isinstance(value, str):
-                value = to_bytes(text=value)
-            else:
-                if isinstance(value, int) and value < 0:
-                    value = 0
-
-                value = to_bytes(value)
-
-        return (
-            # keccak hash if dynamic `bytes` type
-            ("bytes32", keccak(value))
-            if type_ == "bytes"
-            # if fixed bytesXX type, do not hash
-            else (type_, value)
-        )
-
-    elif type_ == "string":
-        if isinstance(value, int):
-            value = to_bytes(value)
-        else:
-            value = to_bytes(text=value)
-        return ("bytes32", keccak(value))
-
-    # allow string values for int and uint types
-    elif type(value) == str and type_.startswith(("int", "uint")):
-        if is_0x_prefixed_hexstr(value):
-            return (type_, to_int(hexstr=value))
-        else:
-            return (type_, to_int(text=value))
-
-    return (type_, value)
-
-
-def find_type_dependencies(type_, types, results=None):
-    if results is None:
-        results = set()
-
-    # a type must be a string
-    if not isinstance(type_, str):
-        raise ValueError(
-            "Invalid find_type_dependencies input: expected string, got "
-            f"`{type_}` of type `{type(type_)}`"
-        )
-    # get core type if it's an array type
-    type_ = parse_core_array_type(type_)
-
-    if (
-        # don't look for dependencies of solidity types
-        type_ in EIP712_SOLIDITY_TYPES
-        # found a type that's already been added
-        or type_ in results
-    ):
-        return results
-
-    # found a type that isn't defined
-    elif type_ not in types:
-        raise ValueError(f"No definition of type `{type_}`")
-
-    results.add(type_)
-
-    for field in types[type_]:
-        find_type_dependencies(field["type"], types, results)
-    return results
-
-
-def encode_type(type_: str, types: Dict[str, List[Dict[str, str]]]) -> str:
-    result = ""
-    unsorted_deps = find_type_dependencies(type_, types)
-    if type_ in unsorted_deps:
-        unsorted_deps.remove(type_)
-
-    deps = [type_] + sorted(list(unsorted_deps))
-    for type_ in deps:
-        children_list = []
-        for child in types[type_]:
-            child_type = child["type"]
-            child_name = child["name"]
-            children_list.append(f"{child_type} {child_name}")
-
-        result += f"{type_}({','.join(children_list)})"
-    return result
-
-
-def hash_type(type_: str, types: Dict[str, List[Dict[str, str]]]) -> bytes:
-    return keccak(to_bytes(text=encode_type(type_, types)))
-
-
-def encode_data(
-    type_: str,
-    types: Dict[str, List[Dict[str, str]]],
-    data: Dict[str, Any],
-) -> bytes:
-    encoded_types: List[str] = ["bytes32"]
-    encoded_values: List[Union[bytes, int]] = [hash_type(type_, types)]
-
-    for field in types[type_]:
-        type, value = encode_field(
-            types, field["name"], field["type"], data.get(field["name"])
-        )
-        encoded_types.append(type)
-        encoded_values.append(value)
-
-    return encode(encoded_types, encoded_values)
-
-
-def hash_struct(
-    type_: str,
-    types: Dict[str, List[Dict[str, str]]],
-    data: Dict[str, Any],
-) -> bytes:
-    encoded = encode_data(type_, types, data)
-    return keccak(encoded)
-
-
-def hash_eip712_message(
-    # returns the same hash as `hash_struct`, but automatically determines primary type
-    message_types: Dict[str, List[Dict[str, str]]],
-    message_data: Dict[str, Any],
-) -> bytes:
-    primary_type = get_primary_type(message_types)
-    return keccak(encode_data(primary_type, message_types, message_data))
-
-
-def hash_domain(domain_data: Dict[str, Any]) -> bytes:
-    eip712_domain_map = {
-        "name": {"name": "name", "type": "string"},
-        "version": {"name": "version", "type": "string"},
-        "chainId": {"name": "chainId", "type": "uint256"},
-        "verifyingContract": {"name": "verifyingContract", "type": "address"},
-        "salt": {"name": "salt", "type": "bytes32"},
-    }
-
-    for k in domain_data.keys():
-        if k not in eip712_domain_map.keys():
-            raise ValueError(f"Invalid domain key: `{k}`")
-
-    domain_types = {
-        "EIP712Domain": [
-            eip712_domain_map[k] for k in eip712_domain_map.keys() if k in domain_data
-        ]
-    }
-
-    return hash_struct("EIP712Domain", domain_types, domain_data)

coinex_api/ccxt/static_dependencies/ethereum/account/encode_typed_data/helpers.py

@@ -1,40 +0,0 @@
-from typing import (
-    Any,
-)
-
-from ...utils import (
-    is_hexstr,
-)
-
-
-def _get_eip712_solidity_types():
-    types = ["bool", "address", "string", "bytes", "uint", "int"]
-    ints = [f"int{(x + 1) * 8}" for x in range(32)]
-    uints = [f"uint{(x + 1) * 8}" for x in range(32)]
-    bytes_ = [f"bytes{x + 1}" for x in range(32)]
-    return types + ints + uints + bytes_
-
-
-EIP712_SOLIDITY_TYPES = _get_eip712_solidity_types()
-
-
-def is_array_type(type_: str) -> bool:
-    return type_.endswith("]")
-
-
-def is_0x_prefixed_hexstr(value: Any) -> bool:
-    return is_hexstr(value) and value.startswith("0x")
-
-
-# strip all brackets: Person[][] -> Person
-def parse_core_array_type(type_: str) -> str:
-    if is_array_type(type_):
-        type_ = type_[: type_.index("[")]
-    return type_
-
-
-# strip only last set of brackets: Person[3][1] -> Person[3]
-def parse_parent_array_type(type_: str) -> str:
-    if is_array_type(type_):
-        type_ = type_[: type_.rindex("[")]
-    return type_