opinion-clob-sdk 0.1.9__tar.gz → 0.1.11__tar.gz

{opinion_clob_sdk-0.1.9 → opinion_clob_sdk-0.1.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opinion_clob_sdk
-Version: 0.1.9
+Version: 0.1.11
 Summary: Opinion CLOB SDK - Python SDK for Opinion Prediction Market Central Limit Order Book API
 Home-page: https://opinion.trade
 Author: Opinion Labs

{opinion_clob_sdk-0.1.9/opinion_clob_sdk → opinion_clob_sdk-0.1.11}/opinion_clob_sdk/__init__.py

@@ -12,7 +12,7 @@ from opinion_clob_sdk.chain.exception import (
     InsufficientGasBalance
 )
 
-__version__ = "0.1.9"
+__version__ = "0.1.11"
 __all__ = [
     "Client",
     "TopicStatus",

{opinion_clob_sdk-0.1.9/opinion_clob_sdk/opinion_clob_sdk → opinion_clob_sdk-0.1.11}/opinion_clob_sdk/chain/py_order_utils/utils.py

@@ -42,19 +42,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 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
-        
+        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 +71,55 @@ 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}")
 
     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
+        # Goal: Calculate taker = floor(maker / price)
+        # Then recalculated_maker = floor(taker * price)
+        #
+        # Note: Due to integer arithmetic, recalculated_maker may be slightly less than
+        # the original maker_amount. This is expected and unavoidable with fixed precision.
+        #
+        # This ensures: given (recalculated_maker, taker, price),
+        # you can always verify: recalculated_maker = floor(taker * price)
+
+        # Calculate taker amount: taker = floor(maker / price)
         exact_taker = maker_decimal / price_decimal
-        taker_amount = int(math.floor(exact_taker))
+        taker_amount = int(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))
+        # Recalculate maker = floor(taker * price) using exact Decimal arithmetic
+        recalculated_maker_decimal = Decimal(str(taker_amount)) * price_decimal
+        recalculated_maker_amount = int(recalculated_maker_decimal)
 
-        # 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
+        # We want: taker = floor(maker * price)
+        # Maker stays the same
+
+        # Calculate exact taker = maker * price
         exact_taker = maker_decimal * price_decimal
-        taker_amount = int(math.floor(exact_taker))
+
+        # Round down to get integer taker
+        taker_amount = int(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  
-    
+    # 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-0.1.9/opinion_clob_sdk → opinion_clob_sdk-0.1.11}/opinion_clob_sdk/opinion_clob_sdk/__init__.py

@@ -12,7 +12,7 @@ from opinion_clob_sdk.chain.exception import (
     InsufficientGasBalance
 )
 
-__version__ = "0.1.9"
+__version__ = "0.1.11"
 __all__ = [
     "Client",
     "TopicStatus",

{opinion_clob_sdk-0.1.9 → opinion_clob_sdk-0.1.11/opinion_clob_sdk}/opinion_clob_sdk/chain/py_order_utils/utils.py

@@ -42,19 +42,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 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
-        
+        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 +71,55 @@ 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}")
 
     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
+        # Goal: Calculate taker = floor(maker / price)
+        # Then recalculated_maker = floor(taker * price)
+        #
+        # Note: Due to integer arithmetic, recalculated_maker may be slightly less than
+        # the original maker_amount. This is expected and unavoidable with fixed precision.
+        #
+        # This ensures: given (recalculated_maker, taker, price),
+        # you can always verify: recalculated_maker = floor(taker * price)
+
+        # Calculate taker amount: taker = floor(maker / price)
         exact_taker = maker_decimal / price_decimal
-        taker_amount = int(math.floor(exact_taker))
+        taker_amount = int(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))
+        # Recalculate maker = floor(taker * price) using exact Decimal arithmetic
+        recalculated_maker_decimal = Decimal(str(taker_amount)) * price_decimal
+        recalculated_maker_amount = int(recalculated_maker_decimal)
 
-        # 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
+        # We want: taker = floor(maker * price)
+        # Maker stays the same
+
+        # Calculate exact taker = maker * price
         exact_taker = maker_decimal * price_decimal
-        taker_amount = int(math.floor(exact_taker))
+
+        # Round down to get integer taker
+        taker_amount = int(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  
-    
+    # 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-0.1.9/opinion_clob_sdk → opinion_clob_sdk-0.1.11}/opinion_clob_sdk/opinion_clob_sdk/opinion_clob_sdk/__init__.py

@@ -12,7 +12,7 @@ from opinion_clob_sdk.chain.exception import (
     InsufficientGasBalance
 )
 
-__version__ = "0.1.9"
+__version__ = "0.1.11"
 __all__ = [
     "Client",
     "TopicStatus",

{opinion_clob_sdk-0.1.9/opinion_clob_sdk → opinion_clob_sdk-0.1.11}/opinion_clob_sdk/opinion_clob_sdk/opinion_clob_sdk/chain/py_order_utils/utils.py

@@ -42,19 +42,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 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
-        
+        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 +71,55 @@ 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}")
 
     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
+        # Goal: Calculate taker = floor(maker / price)
+        # Then recalculated_maker = floor(taker * price)
+        #
+        # Note: Due to integer arithmetic, recalculated_maker may be slightly less than
+        # the original maker_amount. This is expected and unavoidable with fixed precision.
+        #
+        # This ensures: given (recalculated_maker, taker, price),
+        # you can always verify: recalculated_maker = floor(taker * price)
+
+        # Calculate taker amount: taker = floor(maker / price)
         exact_taker = maker_decimal / price_decimal
-        taker_amount = int(math.floor(exact_taker))
+        taker_amount = int(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))
+        # Recalculate maker = floor(taker * price) using exact Decimal arithmetic
+        recalculated_maker_decimal = Decimal(str(taker_amount)) * price_decimal
+        recalculated_maker_amount = int(recalculated_maker_decimal)
 
-        # 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
+        # We want: taker = floor(maker * price)
+        # Maker stays the same
+
+        # Calculate exact taker = maker * price
         exact_taker = maker_decimal * price_decimal
-        taker_amount = int(math.floor(exact_taker))
+
+        # Round down to get integer taker
+        taker_amount = int(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  
-    
+    # 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-0.1.9 → opinion_clob_sdk-0.1.11/opinion_clob_sdk/opinion_clob_sdk/opinion_clob_sdk}/opinion_clob_sdk/__init__.py

@@ -12,7 +12,7 @@ from opinion_clob_sdk.chain.exception import (
     InsufficientGasBalance
 )
 
-__version__ = "0.1.9"
+__version__ = "0.1.11"
 __all__ = [
     "Client",
     "TopicStatus",

{opinion_clob_sdk-0.1.9 → opinion_clob_sdk-0.1.11/opinion_clob_sdk/opinion_clob_sdk}/opinion_clob_sdk/opinion_clob_sdk/chain/py_order_utils/utils.py

@@ -42,19 +42,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 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
-        
+        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 +71,55 @@ 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}")
 
     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
+        # Goal: Calculate taker = floor(maker / price)
+        # Then recalculated_maker = floor(taker * price)
+        #
+        # Note: Due to integer arithmetic, recalculated_maker may be slightly less than
+        # the original maker_amount. This is expected and unavoidable with fixed precision.
+        #
+        # This ensures: given (recalculated_maker, taker, price),
+        # you can always verify: recalculated_maker = floor(taker * price)
+
+        # Calculate taker amount: taker = floor(maker / price)
         exact_taker = maker_decimal / price_decimal
-        taker_amount = int(math.floor(exact_taker))
+        taker_amount = int(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))
+        # Recalculate maker = floor(taker * price) using exact Decimal arithmetic
+        recalculated_maker_decimal = Decimal(str(taker_amount)) * price_decimal
+        recalculated_maker_amount = int(recalculated_maker_decimal)
 
-        # 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
+        # We want: taker = floor(maker * price)
+        # Maker stays the same
+
+        # Calculate exact taker = maker * price
         exact_taker = maker_decimal * price_decimal
-        taker_amount = int(math.floor(exact_taker))
+
+        # Round down to get integer taker
+        taker_amount = int(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  
-    
+    # 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-0.1.11/opinion_clob_sdk/opinion_clob_sdk/opinion_clob_sdk/opinion_clob_sdk/opinion_clob_sdk/__init__.py

@@ -0,0 +1,26 @@
+"""Opinion CLOB SDK - Python SDK for Opinion Prediction Market CLOB API"""
+
+from opinion_clob_sdk.sdk import (
+    Client,
+    CHAIN_ID_BASE_MAINNET,
+    SUPPORTED_CHAIN_IDS
+)
+from opinion_clob_sdk.model import TopicStatus, TopicType, TopicStatusFilter
+from opinion_clob_sdk.chain.exception import (
+    BalanceNotEnough,
+    NoPositionsToRedeem,
+    InsufficientGasBalance
+)
+
+__version__ = "0.1.11"
+__all__ = [
+    "Client",
+    "TopicStatus",
+    "TopicType",
+    "TopicStatusFilter",
+    "CHAIN_ID_BASE_MAINNET",
+    "SUPPORTED_CHAIN_IDS",
+    "BalanceNotEnough",
+    "NoPositionsToRedeem",
+    "InsufficientGasBalance"
+]

opinion_clob_sdk-0.1.11/opinion_clob_sdk/opinion_clob_sdk/opinion_clob_sdk/opinion_clob_sdk/opinion_clob_sdk/chain/py_order_utils/utils.py

@@ -0,0 +1,125 @@
+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.
+
+    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 = floor(maker / price)
+        # Then recalculated_maker = floor(taker * price)
+        #
+        # Note: Due to integer arithmetic, recalculated_maker may be slightly less than
+        # the original maker_amount. This is expected and unavoidable with fixed precision.
+        #
+        # This ensures: given (recalculated_maker, taker, price),
+        # you can always verify: recalculated_maker = floor(taker * price)
+
+        # Calculate taker amount: taker = floor(maker / price)
+        exact_taker = maker_decimal / price_decimal
+        taker_amount = int(exact_taker)
+
+        # Recalculate maker = floor(taker * price) using exact Decimal arithmetic
+        recalculated_maker_decimal = Decimal(str(taker_amount)) * price_decimal
+        recalculated_maker_amount = int(recalculated_maker_decimal)
+
+    else:  # SELL
+        # For SELL: price = taker/maker
+        # We want: taker = floor(maker * price)
+        # Maker stays the same
+
+        # Calculate exact taker = maker * price
+        exact_taker = maker_decimal * price_decimal
+
+        # Round down to get integer taker
+        taker_amount = int(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}")
+
+    # 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-0.1.11/opinion_clob_sdk/opinion_clob_sdk/opinion_clob_sdk/opinion_clob_sdk/opinion_clob_sdk/opinion_clob_sdk/__init__.py

@@ -0,0 +1,26 @@
+"""Opinion CLOB SDK - Python SDK for Opinion Prediction Market CLOB API"""
+
+from opinion_clob_sdk.sdk import (
+    Client,
+    CHAIN_ID_BASE_MAINNET,
+    SUPPORTED_CHAIN_IDS
+)
+from opinion_clob_sdk.model import TopicStatus, TopicType, TopicStatusFilter
+from opinion_clob_sdk.chain.exception import (
+    BalanceNotEnough,
+    NoPositionsToRedeem,
+    InsufficientGasBalance
+)
+
+__version__ = "0.1.11"
+__all__ = [
+    "Client",
+    "TopicStatus",
+    "TopicType",
+    "TopicStatusFilter",
+    "CHAIN_ID_BASE_MAINNET",
+    "SUPPORTED_CHAIN_IDS",
+    "BalanceNotEnough",
+    "NoPositionsToRedeem",
+    "InsufficientGasBalance"
+]