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

opinion_clob_sdk/chain/py_order_utils/abi/FeeManager.py

@@ -0,0 +1,9 @@
+import json
+import os
+
+# Load FeeManager ABI from JSON file
+_current_dir = os.path.dirname(os.path.abspath(__file__))
+_abi_path = os.path.join(_current_dir, 'FeeManager.json')
+
+with open(_abi_path, 'r') as f:
+    abi = json.load(f)

opinion_clob_sdk/chain/py_order_utils/builders/base_builder.py

@@ -20,7 +20,7 @@ class BaseBuilder:
         self, chain_id: int, verifying_contract: str
     ) -> EIP712Struct:
         return make_domain(
-            name="OLAB CTF Exchange",
+            name="OPINION CTF Exchange",
             version="1",
             chainId=str(chain_id),
             verifyingContract=verifying_contract,

opinion_clob_sdk/chain/py_order_utils/builders/order_builder_test.py

@@ -11,7 +11,7 @@ import json
 class TestInterfaces(unittest.TestCase):
     def test_sign_order(self):
         exchange_address = "0xF0aebf65490374a477100351291c736c73c11D9F"
-        chain_id = 8453
+        chain_id = 56
         # Test private key, please do not use the key in production env.
         signer = Signer("0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80")
         builder = OrderBuilder(exchange_address, chain_id, signer, lambda: 1)

opinion_clob_sdk/chain/py_order_utils/utils.py

@@ -29,6 +29,40 @@ def generate_seed() -> int:
     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
@@ -42,19 +76,22 @@ def prepend_zx(in_str: str) -> str:
 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
-        
+        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 = taker/maker
-        For SELL: price = taker/maker
+        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))
@@ -68,48 +105,76 @@ def calculate_order_amounts(price: float, maker_amount: int, side: OrderSide, de
     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}")
+    # 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
 
-    maker_decimal = Decimal(str(maker_amount))
-    decimals_decimal = Decimal(str(decimals))
+    price_fraction = Fraction(str(price)).limit_denominator(1000000)  # Limit denominator to avoid huge numbers
 
     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))
+        # 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
-        # Calculate taker amount: taker = maker * price
-        exact_taker = maker_decimal * price_decimal
-        taker_amount = int(math.floor(exact_taker))
+        # 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
 
-        # 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  
-    
+    # 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/chain/safe/safe_test.py

@@ -12,7 +12,7 @@ class TestSafeRx(unittest.TestCase):
         self.private_key = '0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80'
         self.safe_address = '0x8F58a1ab58e18Bb3f8ACf5E14c046D4F7add824a'
         self.compatibility_handler_address = '0xf48f2B2d2a534e402487b3ee7C18c33Aec0Fe5e4'
-        self.rpc_url = 'https://mainnet.base.org'
+        self.rpc_url = 'https://bsc-dataseed.binance.org'
         self.w3 = Web3(HTTPProvider(self.rpc_url))
 
     def test_sign_multi_sig_tx(self):

opinion_clob_sdk/config.py

@@ -1,4 +1,19 @@
 # Configuration constants for Opinion CLOB SDK
 
 # Supported chain IDs
-SUPPORTED_CHAIN_IDS = [8453, 10143]  # Base mainnet and Base testnet
+SUPPORTED_CHAIN_IDS = [56]  # BNB Chain (BSC) mainnet
+
+# BNB Chain (BSC) Mainnet Contract Addresses
+# All addresses are in checksum format as required by web3.py
+BNB_CHAIN_CONDITIONAL_TOKENS_ADDR = "0xAD1a38cEc043e70E83a3eC30443dB285ED10D774"
+BNB_CHAIN_MULTISEND_ADDR = "0x998739BFdAAdde7C933B942a68053933098f9EDa"
+BNB_CHAIN_FEE_MANAGER_ADDR = "0xC9063Dc52dEEfb518E5b6634A6b8D624bc5d7c36"
+
+# Default contract addresses by chain ID
+DEFAULT_CONTRACT_ADDRESSES = {
+    56: {  # BNB Chain Mainnet
+        "conditional_tokens": BNB_CHAIN_CONDITIONAL_TOKENS_ADDR,
+        "multisend": BNB_CHAIN_MULTISEND_ADDR,
+        "fee_manager": BNB_CHAIN_FEE_MANAGER_ADDR,
+    }
+}

opinion_clob_sdk/model.py

@@ -10,10 +10,34 @@ class TopicStatus(Enum):
     DELETED = 6
 
 class TopicType(Enum):
-    CATEGORICAL = 1
-    BINARY = 0
+    """Topic type for market queries
+    
+    Note: 
+        - ALL (2): All Markets (default)
+        - CATEGORICAL (1): Categorical Market
+        - BINARY (0): Binary Market
+    """
+    ALL = 2  # All Markets - DEFAULT
+    CATEGORICAL = 1  # Categorical Market
+    BINARY = 0  # Binary Market
 
 class TopicStatusFilter(Enum):
     ALL = None
     ACTIVATED = "activated"
     RESOLVED = "resolved"
+
+class TopicSortType(Enum):
+    """Sort type for market queries
+
+    Note: There is no "unsorted" option. If sort_by is not specified,
+    the API defaults to BY_TIME_DESC (newest markets first).
+    """
+    NO_SORT = 0  # Deprecated: API will default to BY_TIME_DESC
+    BY_TIME_DESC = 1  # Sort by creation time (newest first) - DEFAULT
+    BY_CUTOFF_TIME_ASC = 2  # Sort by cutoff time (ending soonest first)
+    BY_VOLUME_DESC = 3  # Sort by total volume (highest first)
+    BY_VOLUME_ASC = 4  # Sort by total volume (lowest first)
+    BY_VOLUME_24H_DESC = 5  # Sort by 24h volume (highest first)
+    BY_VOLUME_24H_ASC = 6  # Sort by 24h volume (lowest first)
+    BY_VOLUME_7D_DESC = 7  # Sort by 7-day volume (highest first)
+    BY_VOLUME_7D_ASC = 8  # Sort by 7-day volume (lowest first)