opinion-clob-sdk 0.1.9__py3-none-any.whl → 0.4.2__py3-none-any.whl

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

@@ -1,115 +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 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.
-    
-    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
-        
-    Returns:
-        tuple[int, int]: A tuple containing (recalculated_maker_amount, taker_amount)
-        For BUY: price = taker/maker
-        For SELL: price = taker/maker
-    """
-    
-    # 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 3 decimal places for prediction markets)
-    if price_decimal.as_tuple().exponent < -3:
-        raise ValueError(f"Price precision cannot exceed 3 decimal places, got {price}")
-
-    maker_decimal = Decimal(str(maker_amount))
-    decimals_decimal = Decimal(str(decimals))
-
-    if side == OrderSide.BUY:
-        # For BUY: price = maker/taker
-        # Calculate taker amount: taker = maker / price
-        # We need to ensure that recalculated_maker = taker * price <= original maker_amount
-        # To avoid precision loss, we iteratively reduce taker until maker fits
-        exact_taker = maker_decimal / price_decimal
-        taker_amount = int(math.floor(exact_taker))
-
-        # Recalculate maker from taker and ensure it doesn't exceed original maker_amount
-        exact_maker = Decimal(str(taker_amount)) * price_decimal
-        recalculated_maker_amount = int(math.floor(exact_maker))
-
-        # If recalculated maker exceeds original, reduce taker by 1 and recalculate
-        while recalculated_maker_amount > maker_amount and taker_amount > 0:
-            taker_amount -= 1
-            exact_maker = Decimal(str(taker_amount)) * price_decimal
-            recalculated_maker_amount = int(math.floor(exact_maker))
-    else:  # SELL
-        # For SELL: price = taker/maker
-        # Calculate taker amount: taker = maker * price
-        exact_taker = maker_decimal * price_decimal
-        taker_amount = int(math.floor(exact_taker))
-
-        # For SELL, maker amount doesn't change
-        recalculated_maker_amount = int(maker_amount)
-    
-    # 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}")
-
-    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/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/opinion_clob_sdk/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/opinion_clob_sdk/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/opinion_clob_sdk/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