ccxt 4.2.77__py2.py3-none-any.whl → 4.4.49__py2.py3-none-any.whl

ccxt/static_dependencies/starknet/utils/typed_data.py

@@ -0,0 +1,182 @@
+from dataclasses import dataclass
+from typing import Dict, List, Union, cast
+
+from ...marshmallow import Schema, fields, post_load
+
+from ..cairo.felt import encode_shortstring
+from ..hash.selector import get_selector_from_name
+from ..hash.utils import compute_hash_on_elements
+from ..models.typed_data import StarkNetDomainDict, TypedDataDict
+
+
+@dataclass(frozen=True)
+class Parameter:
+    """
+    Dataclass representing a Parameter object
+    """
+
+    name: str
+    type: str
+
+
+@dataclass(frozen=True)
+class TypedData:
+    """
+    Dataclass representing a TypedData object
+    """
+
+    types: Dict[str, List[Parameter]]
+    primary_type: str
+    domain: StarkNetDomainDict
+    message: dict
+
+    @staticmethod
+    def from_dict(data: TypedDataDict) -> "TypedData":
+        """
+        Create TypedData dataclass from dictionary.
+
+        :param data: TypedData dictionary.
+        :return: TypedData dataclass instance.
+        """
+        return cast(TypedData, TypedDataSchema().load(data))
+
+    def _is_struct(self, type_name: str) -> bool:
+        return type_name in self.types
+
+    def _encode_value(self, type_name: str, value: Union[int, str, dict, list]) -> int:
+        if is_pointer(type_name) and isinstance(value, list):
+            type_name = strip_pointer(type_name)
+
+            if self._is_struct(type_name):
+                return compute_hash_on_elements(
+                    [self.struct_hash(type_name, data) for data in value]
+                )
+            return compute_hash_on_elements([int(get_hex(val), 16) for val in value])
+
+        if self._is_struct(type_name) and isinstance(value, dict):
+            return self.struct_hash(type_name, value)
+
+        value = cast(Union[int, str], value)
+        return int(get_hex(value), 16)
+
+    def _encode_data(self, type_name: str, data: dict) -> List[int]:
+        values = []
+        for param in self.types[type_name]:
+            encoded_value = self._encode_value(param.type, data[param.name])
+            values.append(encoded_value)
+
+        return values
+
+    def _get_dependencies(self, type_name: str) -> List[str]:
+        if type_name not in self.types:
+            # type_name is a primitive type, has no dependencies
+            return []
+
+        dependencies = set()
+
+        def collect_deps(type_name: str) -> None:
+            for param in self.types[type_name]:
+                fixed_type = strip_pointer(param.type)
+                if fixed_type in self.types and fixed_type not in dependencies:
+                    dependencies.add(fixed_type)
+                    # recursive call
+                    collect_deps(fixed_type)
+
+        # collect dependencies into a set
+        collect_deps(type_name)
+        return [type_name, *list(dependencies)]
+
+    def _encode_type(self, type_name: str) -> str:
+        primary, *dependencies = self._get_dependencies(type_name)
+        types = [primary, *sorted(dependencies)]
+
+        def make_dependency_str(dependency):
+            lst = [f"{t.name}:{t.type}" for t in self.types[dependency]]
+            return f"{dependency}({','.join(lst)})"
+
+        return "".join([make_dependency_str(x) for x in types])
+
+    def type_hash(self, type_name: str) -> int:
+        """
+        Calculate the hash of a type name.
+
+        :param type_name: Name of the type.
+        :return: Hash of the type name.
+        """
+        return get_selector_from_name(self._encode_type(type_name))
+
+    def struct_hash(self, type_name: str, data: dict) -> int:
+        """
+        Calculate the hash of a struct.
+
+        :param type_name: Name of the type.
+        :param data: Data defining the struct.
+        :return: Hash of the struct.
+        """
+        return compute_hash_on_elements(
+            [self.type_hash(type_name), *self._encode_data(type_name, data)]
+        )
+
+    def message_hash(self, account_address: int) -> int:
+        """
+        Calculate the hash of the message.
+
+        :param account_address: Address of an account.
+        :return: Hash of the message.
+        """
+        message = [
+            encode_shortstring("StarkNet Message"),
+            self.struct_hash("StarkNetDomain", cast(dict, self.domain)),
+            account_address,
+            self.struct_hash(self.primary_type, self.message),
+        ]
+
+        return compute_hash_on_elements(message)
+
+
+def get_hex(value: Union[int, str]) -> str:
+    if isinstance(value, int):
+        return hex(value)
+    if value[:2] == "0x":
+        return value
+    if value.isnumeric():
+        return hex(int(value))
+    return hex(encode_shortstring(value))
+
+
+def is_pointer(value: str) -> bool:
+    return len(value) > 0 and value[-1] == "*"
+
+
+def strip_pointer(value: str) -> str:
+    if is_pointer(value):
+        return value[:-1]
+    return value
+
+
+# pylint: disable=unused-argument
+# pylint: disable=no-self-use
+
+
+class ParameterSchema(Schema):
+    name = fields.String(data_key="name", required=True)
+    type = fields.String(data_key="type", required=True)
+
+    @post_load
+    def make_dataclass(self, data, **kwargs) -> Parameter:
+        return Parameter(**data)
+
+
+class TypedDataSchema(Schema):
+    types = fields.Dict(
+        data_key="types",
+        keys=fields.Str(),
+        values=fields.List(fields.Nested(ParameterSchema())),
+    )
+    primary_type = fields.String(data_key="primaryType", required=True)
+    domain = fields.Dict(data_key="domain", required=True)
+    message = fields.Dict(data_key="message", required=True)
+
+    @post_load
+    def make_dataclass(self, data, **kwargs) -> TypedData:
+        return TypedData(**data)

ccxt/static_dependencies/starkware/crypto/fast_pedersen_hash.py

@@ -0,0 +1,50 @@
+from ...ecdsa.curves import Curve
+from ...ecdsa.ellipticcurve import CurveFp, Point
+
+from .signature import (
+    ALPHA,
+    BETA,
+    CONSTANT_POINTS,
+    EC_ORDER,
+    FIELD_PRIME,
+    N_ELEMENT_BITS_HASH,
+    SHIFT_POINT,
+)
+from .utils import from_bytes, to_bytes
+
+curve_stark = CurveFp(FIELD_PRIME, ALPHA, BETA)
+LOW_PART_BITS = 248
+LOW_PART_MASK = 2**248 - 1
+HASH_SHIFT_POINT = Point(curve_stark, SHIFT_POINT[0], SHIFT_POINT[1], EC_ORDER)
+P_0 = Point(curve_stark, CONSTANT_POINTS[2][0], CONSTANT_POINTS[2][1], EC_ORDER)
+P_1 = Point(curve_stark, CONSTANT_POINTS[2 + LOW_PART_BITS][0], CONSTANT_POINTS[2 + LOW_PART_BITS][1], EC_ORDER)
+P_2 = Point(curve_stark, CONSTANT_POINTS[2 + N_ELEMENT_BITS_HASH][0], CONSTANT_POINTS[2 + N_ELEMENT_BITS_HASH][1], EC_ORDER)
+P_3 = Point(curve_stark, CONSTANT_POINTS[2 + N_ELEMENT_BITS_HASH + LOW_PART_BITS][0], CONSTANT_POINTS[2 + N_ELEMENT_BITS_HASH + LOW_PART_BITS][1], EC_ORDER)
+
+def process_single_element(element: int, p1, p2) -> Point:
+    assert 0 <= element < FIELD_PRIME, "Element integer value is out of range"
+
+    high_nibble = element >> LOW_PART_BITS
+    low_part = element & LOW_PART_MASK
+    return low_part * p1 + high_nibble * p2
+
+
+def pedersen_hash(x: int, y: int) -> int:
+    """
+    Computes the Starkware version of the Pedersen hash of x and y.
+    The hash is defined by:
+        shift_point + x_low * P_0 + x_high * P1 + y_low * P2  + y_high * P3
+    where x_low is the 248 low bits of x, x_high is the 4 high bits of x and similarly for y.
+    shift_point, P_0, P_1, P_2, P_3 are constant points generated from the digits of pi.
+    """
+    return (
+        HASH_SHIFT_POINT + process_single_element(x, P_0, P_1) + process_single_element(y, P_2, P_3)
+    ).x()
+
+
+def pedersen_hash_func(x: bytes, y: bytes) -> bytes:
+    """
+    A variant of 'pedersen_hash', where the elements and their resulting hash are in bytes.
+    """
+    assert len(x) == len(y) == 32, "Unexpected element length."
+    return to_bytes(pedersen_hash(*(from_bytes(element) for element in (x, y))))

ccxt/static_dependencies/starkware/crypto/math_utils.py

@@ -0,0 +1,78 @@
+###############################################################################
+# Copyright 2019 StarkWare Industries Ltd.                                    #
+#                                                                             #
+# Licensed under the Apache License, Version 2.0 (the "License").             #
+# You may not use this file except in compliance with the License.            #
+# You may obtain a copy of the License at                                     #
+#                                                                             #
+# https://www.starkware.co/open-source-license/                               #
+#                                                                             #
+# Unless required by applicable law or agreed to in writing,                  #
+# software distributed under the License is distributed on an "AS IS" BASIS,  #
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.    #
+# See the License for the specific language governing permissions             #
+# and limitations under the License.                                          #
+###############################################################################
+
+
+from typing import Tuple
+
+from ...sympy.core.intfunc import igcdex
+
+# A type that represents a point (x,y) on an elliptic curve.
+ECPoint = Tuple[int, int]
+
+def div_mod(n: int, m: int, p: int) -> int:
+    """
+    Finds a nonnegative integer 0 <= x < p such that (m * x) % p == n
+    """
+    a, b, c = igcdex(m, p)
+    assert c == 1
+    return (n * a) % p
+
+def div_ceil(x, y):
+    assert isinstance(x, int) and isinstance(y, int)
+    return -((-x) // y)
+    
+def ec_add(point1: ECPoint, point2: ECPoint, p: int) -> ECPoint:
+    """
+    Gets two points on an elliptic curve mod p and returns their sum.
+    Assumes the points are given in affine form (x, y) and have different x coordinates.
+    """
+    assert (point1[0] - point2[0]) % p != 0
+    m = div_mod(point1[1] - point2[1], point1[0] - point2[0], p)
+    x = (m * m - point1[0] - point2[0]) % p
+    y = (m * (point1[0] - x) - point1[1]) % p
+    return x, y
+
+
+def ec_neg(point: ECPoint, p: int) -> ECPoint:
+    """
+    Given a point (x,y) return (x, -y)
+    """
+    x, y = point
+    return (x, (-y) % p)
+
+
+def ec_double(point: ECPoint, alpha: int, p: int) -> ECPoint:
+    """
+    Doubles a point on an elliptic curve with the equation y^2 = x^3 + alpha*x + beta mod p.
+    Assumes the point is given in affine form (x, y) and has y != 0.
+    """
+    assert point[1] % p != 0
+    m = div_mod(3 * point[0] * point[0] + alpha, 2 * point[1], p)
+    x = (m * m - 2 * point[0]) % p
+    y = (m * (point[0] - x) - point[1]) % p
+    return x, y
+
+
+def ec_mult(m: int, point: ECPoint, alpha: int, p: int) -> ECPoint:
+    """
+    Multiplies by m a point on the elliptic curve with equation y^2 = x^3 + alpha*x + beta mod p.
+    Assumes the point is given in affine form (x, y) and that 0 < m < order(point).
+    """
+    if m == 1:
+        return point
+    if m % 2 == 0:
+        return ec_mult(m // 2, ec_double(point, alpha, p), alpha, p)
+    return ec_add(ec_mult(m - 1, point, alpha, p), point, p)