opinion-clob-sdk 0.1.12__py3-none-any.whl → 0.1.13__py3-none-any.whl

opinion_clob_sdk/opinion_clob_sdk/opinion_clob_sdk/opinion_clob_sdk/opinion_clob_sdk/opinion_clob_sdk/opinion_clob_sdk/opinion_clob_sdk/opinion_clob_sdk/opinion_clob_sdk/opinion_clob_sdk/opinion_clob_sdk/opinion_clob_sdk/chain/py_order_utils/utils.py

@@ -0,0 +1,182 @@
+import math
+import logging
+from eth_utils import to_checksum_address
+from string import punctuation
+from random import random
+from datetime import datetime, timezone
+from .model.sides import OrderSide
+from decimal import Decimal, ROUND_DOWN
+
+max_int = math.pow(2, 32)
+
+
+def normalize(s: str) -> str:
+    lowered = s.lower()
+    for p in punctuation:
+        lowered = lowered.replace(p, "")
+    return lowered
+
+
+def normalize_address(address: str) -> str:
+    return to_checksum_address(address)
+
+
+def generate_seed() -> int:
+    """
+    Pseudo random seed
+    """
+    now = datetime.now().replace(tzinfo=timezone.utc).timestamp()
+    return round(now * random())
+
+
+def round_to_significant_digits(value: int, n: int) -> int:
+    """
+    Round an integer to n significant digits.
+
+    Args:
+        value: The integer to round
+        n: Number of significant digits to keep
+
+    Returns:
+        The rounded integer
+
+    Example:
+        round_to_significant_digits(123456789, 6) -> 123457000
+        round_to_significant_digits(10000000000000000000, 6) -> 10000000000000000000
+    """
+    if value == 0:
+        return 0
+
+    # Get the magnitude (number of digits)
+    magnitude = len(str(abs(value)))
+
+    # If already n digits or fewer, return as-is
+    if magnitude <= n:
+        return value
+
+    # Calculate the divisor to round to n significant digits
+    divisor = 10 ** (magnitude - n)
+
+    # Round to n significant digits
+    rounded = round(value / divisor) * divisor
+
+    return int(rounded)
+
+
+def prepend_zx(in_str: str) -> str:
+    """
+    Prepend 0x to the input string if it is missing
+    """
+    s = in_str
+    if len(s) > 2 and s[:2] != "0x":
+        s = f"0x{s}"
+    return s
+
+
+def calculate_order_amounts(price: float, maker_amount: int, side: OrderSide, decimals: int) -> tuple[int, int]:
+    """
+    Calculate the maker and taker amounts based on the price and side.
+
+    Uses precise Decimal arithmetic to ensure precision within 6 significant digits
+    (matching the matching engine's precision limit).
+
+    Args:
+        price: The price of the order (between 0.001 and 0.999)
+        maker_amount: The maker amount in base units
+        side: The order side (BUY or SELL)
+        decimals: The number of decimal places for the currency (unused, kept for compatibility)
+
+    Returns:
+        tuple[int, int]: A tuple containing (recalculated_maker_amount, taker_amount)
+        For BUY: price = maker/taker, so taker = maker/price
+        For SELL: price = taker/maker, so taker = maker*price
+    """
+
+    # Validate price using Decimal for exact comparison
+    try:
+        price_decimal = Decimal(str(price))
+    except (ValueError, TypeError) as e:
+        raise ValueError(f"Invalid price format: {price}") from e
+
+    # Define min/max price as Decimal for exact comparison
+    min_price = Decimal("0.001")
+    max_price = Decimal("0.999")
+
+    if not (min_price <= price_decimal <= max_price):
+        raise ValueError(f"Price must be between {min_price} and {max_price} (inclusive), got {price}")
+
+    # Ensure price doesn't have excessive precision (max 6 decimal places to match engine precision)
+    if price_decimal.as_tuple().exponent < -6:
+        raise ValueError(f"Price precision cannot exceed 6 decimal places, got {price}")
+
+    maker_decimal = Decimal(str(maker_amount))
+
+    if side == OrderSide.BUY:
+        # For BUY: price = maker/taker
+        # Goal: Calculate taker and maker with only 6 significant digits each
+        # to match the matching engine's precision requirement
+        #
+        # Strategy:
+        # 1. Round maker_amount to 6 significant digits
+        # 2. Calculate taker = round(maker_6digit / price) to 6 significant digits
+        # 3. Recalculate maker = round(taker_6digit * price) to verify precision
+        #
+        # This ensures: maker_6digit / taker_6digit = price (exact match within 6 digits)
+
+        # Step 1: Round maker to 6 significant digits
+        maker_6digit = round_to_significant_digits(maker_amount, 6)
+
+        # Step 2: Calculate taker = maker / price
+        exact_taker = Decimal(str(maker_6digit)) / price_decimal
+        taker_amount = int(exact_taker)
+
+        # Step 3: Round taker to 6 significant digits
+        taker_6digit = round_to_significant_digits(taker_amount, 6)
+
+        # Step 4: Recalculate maker using 6-digit taker to ensure precision
+        recalculated_maker_decimal = Decimal(str(taker_6digit)) * price_decimal
+        recalculated_maker_amount = int(recalculated_maker_decimal)
+
+        # Step 5: Round recalculated maker to 6 significant digits
+        recalculated_maker_6digit = round_to_significant_digits(recalculated_maker_amount, 6)
+
+        # Use the 6-digit values
+        taker_amount = taker_6digit
+        recalculated_maker_amount = recalculated_maker_6digit
+
+    else:  # SELL
+        # For SELL: price = taker/maker
+        # Goal: Calculate taker and maker with only 6 significant digits each
+        #
+        # Strategy:
+        # 1. Round maker_amount to 6 significant digits
+        # 2. Calculate taker = round(maker_6digit * price) to 6 significant digits
+        # 3. This ensures: taker_6digit / maker_6digit = price (exact match within 6 digits)
+
+        # Step 1: Round maker to 6 significant digits
+        maker_6digit = round_to_significant_digits(maker_amount, 6)
+
+        # Step 2: Calculate taker = maker * price
+        exact_taker = Decimal(str(maker_6digit)) * price_decimal
+        taker_amount = int(exact_taker)
+
+        # Step 3: Round taker to 6 significant digits
+        taker_6digit = round_to_significant_digits(taker_amount, 6)
+
+        # Use the 6-digit values
+        taker_amount = taker_6digit
+        recalculated_maker_amount = maker_6digit
+
+    # Ensure amounts are at least 1
+    taker_amount = int(max(1, taker_amount))
+    recalculated_maker_amount = int(max(1, recalculated_maker_amount))
+
+    logging.debug(f"Order calculation: taker_amount={taker_amount}, recalculated_maker_amount={recalculated_maker_amount}")
+
+    # Validate the calculated price is within bounds
+    calculated_price = recalculated_maker_amount / taker_amount if side == OrderSide.BUY else taker_amount / recalculated_maker_amount
+
+    if calculated_price > 0.999 or calculated_price < 0.001:
+        raise ValueError("invalid taker_amount and recalculated_maker_amount")
+
+    return recalculated_maker_amount, taker_amount

opinion_clob_sdk/opinion_clob_sdk/opinion_clob_sdk/opinion_clob_sdk/opinion_clob_sdk/opinion_clob_sdk/opinion_clob_sdk/opinion_clob_sdk/opinion_clob_sdk/opinion_clob_sdk/opinion_clob_sdk/opinion_clob_sdk/opinion_clob_sdk/chain/safe/constants.py

@@ -0,0 +1,19 @@
+from eth_typing import ChecksumAddress, HexAddress, HexStr, Hash32
+from enum import Enum
+
+NULL_ADDRESS: ChecksumAddress = ChecksumAddress(HexAddress(HexStr("0x" + "0" * 40)))
+NULL_HASH: Hash32 = Hash32(bytes.fromhex(HexStr("0" * 64)))
+
+# Gas required to transfer a regular token. Assume the worst scenario with a regular token transfer without storage
+# initialized (payment_receiver no previous owner of token)
+TOKEN_TRANSFER_GAS = 60_000
+
+
+class TxSpeed(Enum):
+    SLOWEST = 0
+    VERY_SLOW = 1
+    SLOW = 2
+    NORMAL = 3
+    FAST = 4
+    VERY_FAST = 5
+    FASTEST = 6

opinion_clob_sdk/opinion_clob_sdk/opinion_clob_sdk/opinion_clob_sdk/opinion_clob_sdk/opinion_clob_sdk/opinion_clob_sdk/opinion_clob_sdk/opinion_clob_sdk/opinion_clob_sdk/opinion_clob_sdk/opinion_clob_sdk/opinion_clob_sdk/chain/safe/eip712/__init__.py

@@ -0,0 +1,176 @@
+"""
+Based on https://github.com/jvinet/eip712, adjustments by https://github.com/uxio0
+
+Routines for EIP712 encoding and signing.
+
+Copyright (C) 2022 Judd Vinet <jvinet@zeroflux.org>
+                   Uxío Fuentefría <uxio@safe.global>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+"""
+import re
+from typing import Any, Dict, Tuple
+
+from eth_abi import encode as encode_abi
+from eth_typing import Hash32
+from hexbytes import HexBytes
+
+from ..utils import fast_keccak
+
+
+def encode_data(primary_type: str, data, types):
+    """
+    Encode structured data as per Ethereum's signTypeData_v4.
+
+    https://docs.metamask.io/guide/signing-data.html#sign-typed-data-v4
+
+    This code is ported from the Javascript "eth-sig-util" package.
+    """
+    encoded_types = ["bytes32"]
+    encoded_values = [hash_type(primary_type, types)]
+
+    def _encode_field(name, typ, value):
+        if typ in types:
+            if value is None:
+                return [
+                    "bytes32",
+                    "0x0000000000000000000000000000000000000000000000000000000000000000",
+                ]
+            else:
+                return ["bytes32", fast_keccak(encode_data(typ, value, types))]
+
+        if value is None:
+            raise Exception(f"Missing value for field {name} of type {type}")
+
+        # Accept string bytes
+        if "bytes" in typ and isinstance(value, str):
+            value = HexBytes(value)
+
+        # Accept string uint and int
+        if "int" in typ and isinstance(value, str):
+            value = int(value)
+
+        if typ == "bytes":
+            return ["bytes32", fast_keccak(value)]
+
+        if typ == "string":
+            # Convert string to bytes.
+            value = value.encode("utf-8")
+            return ["bytes32", fast_keccak(value)]
+
+        if typ.endswith("]"):
+            # Array type
+            if value:
+                parsed_type = typ[: typ.rindex("[")]
+                type_value_pairs = [_encode_field(name, parsed_type, v) for v in value]
+                data_types, data_hashes = zip(*type_value_pairs)
+            else:
+                # Empty array
+                data_types, data_hashes = [], []
+
+            h = fast_keccak(encode_abi(data_types, data_hashes))
+            return ["bytes32", h]
+
+        return [typ, value]
+
+    for field in types[primary_type]:
+        typ, val = _encode_field(field["name"], field["type"], data[field["name"]])
+        encoded_types.append(typ)
+        encoded_values.append(val)
+
+    return encode_abi(encoded_types, encoded_values)
+
+
+def encode_type(primary_type: str, types) -> str:
+    result = ""
+    deps = find_type_dependencies(primary_type, types)
+    deps = sorted([d for d in deps if d != primary_type])
+    deps = [primary_type] + deps
+    for typ in deps:
+        children = types[typ]
+        if not children:
+            raise Exception(f"No type definition specified: {type}")
+
+        defs = [f"{t['type']} {t['name']}" for t in types[typ]]
+        result += typ + "(" + ",".join(defs) + ")"
+    return result
+
+
+def find_type_dependencies(primary_type: str, types, results=None):
+    if results is None:
+        results = []
+
+    primary_type = re.split(r"\W", primary_type)[0]
+    if primary_type in results or not types.get(primary_type):
+        return results
+    results.append(primary_type)
+
+    for field in types[primary_type]:
+        deps = find_type_dependencies(field["type"], types, results)
+        for dep in deps:
+            if dep not in results:
+                results.append(dep)
+
+    return results
+
+
+def hash_type(primary_type: str, types) -> Hash32:
+    return fast_keccak(encode_type(primary_type, types).encode())
+
+
+def hash_struct(primary_type: str, data, types) -> Hash32:
+    return fast_keccak(encode_data(primary_type, data, types))
+
+
+def eip712_encode(typed_data: Dict[str, Any]) -> Tuple[bytes, Hash32, Hash32]:
+    """
+    Given a dict of structured data and types, return a 3-element tuple of
+    the encoded, signable data.
+
+      0: The magic & version (0x1901)
+      1: The encoded types
+      2: The encoded data
+    """
+    try:
+        parts = (
+            bytes.fromhex("1901"),
+            hash_struct("EIP712Domain", typed_data["domain"], typed_data["types"]),
+        )
+        if typed_data["primaryType"] == "EIP712Domain":
+            raise TypeError("primaryType cannot be EIP712Domain")
+
+        return (
+            *parts,
+            hash_struct(
+                typed_data["primaryType"],
+                typed_data["message"],
+                typed_data["types"],
+            ),
+        )
+
+    except (KeyError, AttributeError, TypeError, IndexError) as exc:
+        raise ValueError(f"Not valid {typed_data}") from exc
+
+
+def eip712_encode_hash(typed_data: Dict[str, Any]) -> Hash32:
+    """
+    :param typed_data: EIP712 structured data and types
+    :return: Keccak256 hash of encoded signable data
+    """
+    return fast_keccak(b"".join(eip712_encode(typed_data)))

opinion_clob_sdk/opinion_clob_sdk/opinion_clob_sdk/opinion_clob_sdk/opinion_clob_sdk/opinion_clob_sdk/opinion_clob_sdk/opinion_clob_sdk/opinion_clob_sdk/opinion_clob_sdk/opinion_clob_sdk/opinion_clob_sdk/opinion_clob_sdk/chain/safe/enums.py

@@ -0,0 +1,6 @@
+from enum import Enum
+
+
+class SafeOperationEnum(Enum):
+    CALL = 0
+    DELEGATE_CALL = 1

opinion_clob_sdk/opinion_clob_sdk/opinion_clob_sdk/opinion_clob_sdk/opinion_clob_sdk/opinion_clob_sdk/opinion_clob_sdk/opinion_clob_sdk/opinion_clob_sdk/opinion_clob_sdk/opinion_clob_sdk/opinion_clob_sdk/opinion_clob_sdk/chain/safe/exceptions.py

@@ -0,0 +1,94 @@
+class SafeServiceException(Exception):
+    pass
+
+
+class CannotEstimateGas(SafeServiceException):
+    pass
+
+
+class CannotRetrieveSafeInfoException(SafeServiceException):
+    pass
+
+
+class InvalidChecksumAddress(SafeServiceException):
+    pass
+
+
+class InvalidPaymentToken(SafeServiceException):
+    pass
+
+
+class InvalidMultisigTx(SafeServiceException):
+    pass
+
+
+class InvalidInternalTx(InvalidMultisigTx):
+    pass
+
+
+class SignatureNotProvidedByOwner(InvalidMultisigTx):
+    pass
+
+
+class SignaturesDataTooShort(InvalidMultisigTx):
+    pass
+
+
+class InvalidOwnerProvided(InvalidMultisigTx):
+    pass
+
+
+class InvalidSignaturesProvided(InvalidMultisigTx):
+    pass
+
+
+class CouldNotPayGasWithEther(InvalidMultisigTx):
+    pass
+
+
+class CouldNotFinishInitialization(InvalidMultisigTx):
+    pass
+
+
+class ThresholdNeedsToBeDefined(InvalidMultisigTx):
+    pass
+
+
+class SafeTransactionFailedWhenGasPriceAndSafeTxGasEmpty(InvalidMultisigTx):
+    pass
+
+
+class MethodCanOnlyBeCalledFromThisContract(InvalidMultisigTx):
+    pass
+
+
+class CouldNotPayGasWithToken(InvalidMultisigTx):
+    pass
+
+
+class HashHasNotBeenApproved(InvalidMultisigTx):
+    pass
+
+
+class NotEnoughSafeTransactionGas(InvalidMultisigTx):
+    pass
+
+
+class InvalidContractSignatureLocation(InvalidMultisigTx):
+    pass
+
+
+class OnlyOwnersCanApproveAHash(InvalidMultisigTx):
+    pass
+
+
+class OwnerManagerException(InvalidMultisigTx):
+    pass
+
+
+class ModuleManagerException(InvalidMultisigTx):
+    pass
+
+
+class InvalidERC20Token(Exception):
+    pass