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

opinion_clob_sdk/__init__.py

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

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,69 @@ 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: Find maximum taker such that floor(taker * price) <= maker
+        # Then use recalculated_maker = floor(taker * price)
+        #
+        # This ensures precision: given (recalculated_maker, taker, price),
+        # you can always verify: recalculated_maker = floor(taker * price)
+
+        # Calculate exact taker = maker / price
         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))
+        # Start with floor(exact_taker)
+        taker_amount = int(exact_taker)
+
+        # Calculate corresponding maker = floor(taker * price)
+        recalculated_maker_decimal = Decimal(str(taker_amount)) * price_decimal
+        recalculated_maker_amount = int(recalculated_maker_decimal)
+
+        # Try to increment taker to use more of the available maker amount
+        # but ensure we don't exceed the original maker_amount
+        while taker_amount > 0:
+            test_taker = taker_amount + 1
+            test_maker_decimal = Decimal(str(test_taker)) * price_decimal
+            test_maker = int(test_maker_decimal)
+
+            if test_maker <= maker_amount:
+                # We can use this higher taker value
+                taker_amount = test_taker
+                recalculated_maker_amount = test_maker
+            else:
+                # Can't increase further without exceeding maker_amount
+                break
 
-        # 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/opinion_clob_sdk/__init__.py

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

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,69 @@ 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: Find maximum taker such that floor(taker * price) <= maker
+        # Then use recalculated_maker = floor(taker * price)
+        #
+        # This ensures precision: given (recalculated_maker, taker, price),
+        # you can always verify: recalculated_maker = floor(taker * price)
+
+        # Calculate exact taker = maker / price
         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))
+        # Start with floor(exact_taker)
+        taker_amount = int(exact_taker)
+
+        # Calculate corresponding maker = floor(taker * price)
+        recalculated_maker_decimal = Decimal(str(taker_amount)) * price_decimal
+        recalculated_maker_amount = int(recalculated_maker_decimal)
+
+        # Try to increment taker to use more of the available maker amount
+        # but ensure we don't exceed the original maker_amount
+        while taker_amount > 0:
+            test_taker = taker_amount + 1
+            test_maker_decimal = Decimal(str(test_taker)) * price_decimal
+            test_maker = int(test_maker_decimal)
+
+            if test_maker <= maker_amount:
+                # We can use this higher taker value
+                taker_amount = test_taker
+                recalculated_maker_amount = test_maker
+            else:
+                # Can't increase further without exceeding maker_amount
+                break
 
-        # 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/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.10"
 __all__ = [
     "Client",
     "TopicStatus",

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,69 @@ 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: Find maximum taker such that floor(taker * price) <= maker
+        # Then use recalculated_maker = floor(taker * price)
+        #
+        # This ensures precision: given (recalculated_maker, taker, price),
+        # you can always verify: recalculated_maker = floor(taker * price)
+
+        # Calculate exact taker = maker / price
         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))
+        # Start with floor(exact_taker)
+        taker_amount = int(exact_taker)
+
+        # Calculate corresponding maker = floor(taker * price)
+        recalculated_maker_decimal = Decimal(str(taker_amount)) * price_decimal
+        recalculated_maker_amount = int(recalculated_maker_decimal)
+
+        # Try to increment taker to use more of the available maker amount
+        # but ensure we don't exceed the original maker_amount
+        while taker_amount > 0:
+            test_taker = taker_amount + 1
+            test_maker_decimal = Decimal(str(test_taker)) * price_decimal
+            test_maker = int(test_maker_decimal)
+
+            if test_maker <= maker_amount:
+                # We can use this higher taker value
+                taker_amount = test_taker
+                recalculated_maker_amount = test_maker
+            else:
+                # Can't increase further without exceeding maker_amount
+                break
 
-        # 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/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.10"
 __all__ = [
     "Client",
     "TopicStatus",

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,69 @@ 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: Find maximum taker such that floor(taker * price) <= maker
+        # Then use recalculated_maker = floor(taker * price)
+        #
+        # This ensures precision: given (recalculated_maker, taker, price),
+        # you can always verify: recalculated_maker = floor(taker * price)
+
+        # Calculate exact taker = maker / price
         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))
+        # Start with floor(exact_taker)
+        taker_amount = int(exact_taker)
+
+        # Calculate corresponding maker = floor(taker * price)
+        recalculated_maker_decimal = Decimal(str(taker_amount)) * price_decimal
+        recalculated_maker_amount = int(recalculated_maker_decimal)
+
+        # Try to increment taker to use more of the available maker amount
+        # but ensure we don't exceed the original maker_amount
+        while taker_amount > 0:
+            test_taker = taker_amount + 1
+            test_maker_decimal = Decimal(str(test_taker)) * price_decimal
+            test_maker = int(test_maker_decimal)
+
+            if test_maker <= maker_amount:
+                # We can use this higher taker value
+                taker_amount = test_taker
+                recalculated_maker_amount = test_maker
+            else:
+                # Can't increase further without exceeding maker_amount
+                break
 
-        # 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/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.10"
 __all__ = [
     "Client",
     "TopicStatus",

opinion_clob_sdk/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,69 @@ 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: Find maximum taker such that floor(taker * price) <= maker
+        # Then use recalculated_maker = floor(taker * price)
+        #
+        # This ensures precision: given (recalculated_maker, taker, price),
+        # you can always verify: recalculated_maker = floor(taker * price)
+
+        # Calculate exact taker = maker / price
         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))
+        # Start with floor(exact_taker)
+        taker_amount = int(exact_taker)
+
+        # Calculate corresponding maker = floor(taker * price)
+        recalculated_maker_decimal = Decimal(str(taker_amount)) * price_decimal
+        recalculated_maker_amount = int(recalculated_maker_decimal)
+
+        # Try to increment taker to use more of the available maker amount
+        # but ensure we don't exceed the original maker_amount
+        while taker_amount > 0:
+            test_taker = taker_amount + 1
+            test_maker_decimal = Decimal(str(test_taker)) * price_decimal
+            test_maker = int(test_maker_decimal)
+
+            if test_maker <= maker_amount:
+                # We can use this higher taker value
+                taker_amount = test_taker
+                recalculated_maker_amount = test_maker
+            else:
+                # Can't increase further without exceeding maker_amount
+                break
 
-        # 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