bitmart 0.0.116__py3-none-any.whl

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

@@ -0,0 +1,230 @@
+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

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

@@ -0,0 +1,83 @@
+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

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

@@ -0,0 +1,27 @@
+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)

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

@@ -0,0 +1,19 @@
+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

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

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

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

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

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

@@ -0,0 +1,239 @@
+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)

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

@@ -0,0 +1,40 @@
+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_