opinion-clob-sdk 0.1.15__py3-none-any.whl → 0.1.16__py3-none-any.whl

opinion_clob_sdk/opinion_clob_sdk/chain/py_order_utils/utils.py

@@ -1,180 +0,0 @@
-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 and ensures the calculated price from amounts
-    exactly matches the input price by using fractional representation.
-
-    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}")
-
-    # Convert price to fraction for exact representation
-    # E.g., 0.111 = 111/1000, 0.222 = 222/1000 = 111/500 (simplified)
-    from fractions import Fraction
-    import math
-
-    price_fraction = Fraction(str(price)).limit_denominator(1000000)  # Limit denominator to avoid huge numbers
-
-    if side == OrderSide.BUY:
-        # For BUY: price = maker/taker
-        # Goal: Ensure maker/taker = price_num/price_denom EXACTLY
-        #
-        # Strategy:
-        # 1. Round maker to 4 significant digits
-        # 2. Find the closest (maker', taker') pair where:
-        #    maker'/taker' = price_num/price_denom exactly
-        #    maker' is close to maker_4digit
-        #
-        # Method: maker' = k * price_num, taker' = k * price_denom
-        # Choose k such that maker' ≈ maker_4digit
-
-        # Step 1: Round maker to 4 significant digits as target
-        maker_4digit = round_to_significant_digits(maker_amount, 4)
-
-        # Step 2: Find the scaling factor k
-        # We want: k * price_num ≈ maker_4digit
-        # So: k ≈ maker_4digit / price_num
-        k = maker_4digit // price_fraction.numerator
-        if k == 0:
-            k = 1  # Ensure at least k=1
-
-        # Step 3: Calculate exact maker and taker using k
-        # This guarantees: recalculated_maker_amount / taker_amount = price_num / price_denom
-        recalculated_maker_amount = k * price_fraction.numerator
-        taker_amount = k * price_fraction.denominator
-
-    else:  # SELL
-        # For SELL: price = taker/maker
-        # Goal: Ensure taker/maker = price_num/price_denom EXACTLY
-        #
-        # Method: taker = k * price_num, maker = k * price_denom
-        # Choose k such that maker ≈ maker_4digit
-
-        # Step 1: Round maker to 4 significant digits
-        maker_4digit = round_to_significant_digits(maker_amount, 4)
-
-        # Step 2: Find the scaling factor k
-        # We want: k * price_denom ≈ maker_4digit
-        # So: k ≈ maker_4digit / price_denom
-        k = maker_4digit // price_fraction.denominator
-        if k == 0:
-            k = 1
-
-        # Step 3: Calculate exact maker and taker using k
-        recalculated_maker_amount = k * price_fraction.denominator
-        taker_amount = k * price_fraction.numerator
-
-    # 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/chain/safe/constants.py

@@ -1,19 +0,0 @@
-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/chain/safe/eip712/__init__.py

@@ -1,176 +0,0 @@
-"""
-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/chain/safe/enums.py

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

opinion_clob_sdk/opinion_clob_sdk/chain/safe/exceptions.py

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