opinion-clob-sdk 0.1.14__tar.gz → 0.1.16__tar.gz

{opinion_clob_sdk-0.1.14 → opinion_clob_sdk-0.1.16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opinion_clob_sdk
-Version: 0.1.14
+Version: 0.1.16
 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.14/opinion_clob_sdk/opinion_clob_sdk → opinion_clob_sdk-0.1.16}/__init__.py

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

{opinion_clob_sdk-0.1.14/opinion_clob_sdk/opinion_clob_sdk → opinion_clob_sdk-0.1.16}/chain/py_order_utils/utils.py

@@ -77,8 +77,8 @@ def calculate_order_amounts(price: float, maker_amount: int, side: OrderSide, de
     """
     Calculate the maker and taker amounts based on the price and side.
 
-    Uses precise Decimal arithmetic to ensure precision within 4 significant digits
-    (to stay well within the matching engine's 6-digit precision limit).
+    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)
@@ -109,63 +109,61 @@ def calculate_order_amounts(price: float, maker_amount: int, side: OrderSide, de
     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))
+    # 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: Calculate taker and maker with only 4 significant digits each
-        # to stay well within the matching engine's 6-digit precision limit
+        # Goal: Ensure maker/taker = price_num/price_denom EXACTLY
         #
         # Strategy:
-        # 1. Round maker_amount to 4 significant digits
-        # 2. Calculate taker = round(maker_4digit / price) to 4 significant digits
-        # 3. Recalculate maker = round(taker_4digit * price) to verify precision
+        # 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
         #
-        # This ensures: maker_4digit / taker_4digit = price (exact match within 4 digits)
+        # Method: maker' = k * price_num, taker' = k * price_denom
+        # Choose k such that maker' ≈ maker_4digit
 
-        # Step 1: Round maker to 4 significant digits
+        # Step 1: Round maker to 4 significant digits as target
         maker_4digit = round_to_significant_digits(maker_amount, 4)
 
-        # Step 2: Calculate taker = maker / price
-        exact_taker = Decimal(str(maker_4digit)) / price_decimal
-        taker_amount = int(exact_taker)
-
-        # Step 3: Round taker to 4 significant digits
-        taker_4digit = round_to_significant_digits(taker_amount, 4)
-
-        # Step 4: Recalculate maker using 4-digit taker to ensure precision
-        recalculated_maker_decimal = Decimal(str(taker_4digit)) * price_decimal
-        recalculated_maker_amount = int(recalculated_maker_decimal)
+        # 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 5: Round recalculated maker to 4 significant digits
-        recalculated_maker_4digit = round_to_significant_digits(recalculated_maker_amount, 4)
-
-        # Use the 4-digit values
-        taker_amount = taker_4digit
-        recalculated_maker_amount = recalculated_maker_4digit
+        # 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: Calculate taker and maker with only 4 significant digits each
+        # Goal: Ensure taker/maker = price_num/price_denom EXACTLY
         #
-        # Strategy:
-        # 1. Round maker_amount to 4 significant digits
-        # 2. Calculate taker = round(maker_4digit * price) to 4 significant digits
-        # 3. This ensures: taker_4digit / maker_4digit = price (exact match within 4 digits)
+        # 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: Calculate taker = maker * price
-        exact_taker = Decimal(str(maker_4digit)) * price_decimal
-        taker_amount = int(exact_taker)
-
-        # Step 3: Round taker to 4 significant digits
-        taker_4digit = round_to_significant_digits(taker_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
 
-        # Use the 4-digit values
-        taker_amount = taker_4digit
-        recalculated_maker_amount = maker_4digit
+        # 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))

opinion_clob_sdk-0.1.16/opinion_clob_sdk.egg-info/PKG-INFO

@@ -0,0 +1,97 @@
+Metadata-Version: 2.4
+Name: opinion_clob_sdk
+Version: 0.1.16
+Summary: Opinion CLOB SDK - Python SDK for Opinion Prediction Market Central Limit Order Book API
+Home-page: https://opinion.trade
+Author: Opinion Labs
+Author-email: support@opinion.trade
+Keywords: PredictionMarket,CLOB,Trading,Blockchain,Base,Opinion
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: urllib3>=2.3.0
+Requires-Dist: six>=1.17.0
+Requires-Dist: certifi>=2024.12.14
+Requires-Dist: python-dateutil>=2.9.0.post0
+Requires-Dist: hexbytes>=1.2.1
+Requires-Dist: web3>=7.6.1
+Requires-Dist: eth_account>=0.13.0
+Requires-Dist: poly_eip712_structs>=0.0.1
+Requires-Dist: opinion_api>=0.1.1
+Requires-Dist: pytest>=7.0.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+
+# Opinion CLOB SDK
+
+Python SDK for interacting with Opinion prediction markets via the CLOB (Central Limit Order Book) API.
+
+## Features
+
+- Market data queries (markets, orderbooks, prices, candles)
+- Order management (place, cancel, query orders)
+- Position and balance tracking
+- Smart contract interactions (split, merge, redeem)
+- Support for Base mainnet (chain ID 8453)
+
+## Installation
+
+```bash
+pip install opinion_clob_sdk
+```
+
+## Quick Start
+
+```python
+from opinion_clob_sdk import Client
+
+client = Client(
+    host='https://api.opinion.trade',
+    apikey='your_api_key',
+    chain_id=8453,  # Base mainnet
+    rpc_url='your_rpc_url',
+    private_key='your_private_key',
+    multi_sig_addr='your_multi_sig_address'
+)
+
+# Get markets
+markets = client.get_markets(page=1, limit=10)
+
+# Get orderbook
+orderbook = client.get_orderbook(token_id='token_id')
+
+# Place an order
+from opinion_clob_sdk.chain.py_order_utils.model.order import PlaceOrderDataInput
+from opinion_clob_sdk.chain.py_order_utils.model.sides import OrderSide
+from opinion_clob_sdk.chain.py_order_utils.model.order_type import LIMIT_ORDER
+
+order_data = PlaceOrderDataInput(
+    marketId=123,
+    tokenId='token_id',
+    side=OrderSide.BUY,
+    orderType=LIMIT_ORDER,
+    price='0.5',
+    makerAmountInQuoteToken=10
+)
+
+result = client.place_order(order_data)
+```
+    

opinion_clob_sdk-0.1.16/opinion_clob_sdk.egg-info/SOURCES.txt

@@ -0,0 +1,56 @@
+MANIFEST.in
+README.md
+setup.py
+./__init__.py
+./config.py
+./model.py
+./sdk.py
+./verify_api_calls.py
+./chain/__init__.py
+./chain/contract_caller.py
+./chain/exception.py
+./chain/contracts/__init__.py
+./chain/contracts/conditional_tokens.py
+./chain/contracts/erc20.py
+./chain/py_order_utils/__init__.py
+./chain/py_order_utils/constants.py
+./chain/py_order_utils/signer.py
+./chain/py_order_utils/utils.py
+./chain/py_order_utils/builders/__init__.py
+./chain/py_order_utils/builders/base_builder.py
+./chain/py_order_utils/builders/exception.py
+./chain/py_order_utils/builders/order_builder.py
+./chain/py_order_utils/builders/order_builder_test.py
+./chain/py_order_utils/model/__init__.py
+./chain/py_order_utils/model/order.py
+./chain/py_order_utils/model/order_type.py
+./chain/py_order_utils/model/sides.py
+./chain/py_order_utils/model/signatures.py
+./chain/safe/__init__.py
+./chain/safe/constants.py
+./chain/safe/enums.py
+./chain/safe/exceptions.py
+./chain/safe/multisend.py
+./chain/safe/safe.py
+./chain/safe/safe_signature.py
+./chain/safe/safe_test.py
+./chain/safe/safe_tx.py
+./chain/safe/signatures.py
+./chain/safe/typing.py
+./chain/safe/utils.py
+./chain/safe/eip712/__init__.py
+./chain/safe/safe_contracts/__init__.py
+./chain/safe/safe_contracts/compatibility_fallback_handler_v1_3_0.py
+./chain/safe/safe_contracts/multisend_v1_3_0.py
+./chain/safe/safe_contracts/safe_v1_3_0.py
+./chain/safe/safe_contracts/utils.py
+opinion_clob_sdk.egg-info/PKG-INFO
+opinion_clob_sdk.egg-info/SOURCES.txt
+opinion_clob_sdk.egg-info/dependency_links.txt
+opinion_clob_sdk.egg-info/requires.txt
+opinion_clob_sdk.egg-info/top_level.txt
+tests/test_integration.py
+tests/test_model.py
+tests/test_order_calculations.py
+tests/test_precision.py
+tests/test_sdk.py

opinion_clob_sdk-0.1.16/opinion_clob_sdk.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

opinion_clob_sdk-0.1.16/opinion_clob_sdk.egg-info/requires.txt

@@ -0,0 +1,10 @@
+urllib3>=2.3.0
+six>=1.17.0
+certifi>=2024.12.14
+python-dateutil>=2.9.0.post0
+hexbytes>=1.2.1
+web3>=7.6.1
+eth_account>=0.13.0
+poly_eip712_structs>=0.0.1
+opinion_api>=0.1.1
+pytest>=7.0.0

opinion_clob_sdk-0.1.16/opinion_clob_sdk.egg-info/top_level.txt

@@ -0,0 +1 @@
+opinion_clob_sdk

{opinion_clob_sdk-0.1.14 → opinion_clob_sdk-0.1.16}/setup.py

@@ -1,7 +1,7 @@
 from setuptools import setup, find_packages
 
 NAME = "opinion_clob_sdk"
-VERSION = "0.1.14"
+VERSION = "0.1.16"
 
 setup(
     name=NAME,
@@ -80,8 +80,18 @@ result = client.place_order(order_data)
         "opinion_api >= 0.1.1",
         "pytest >= 7.0.0",
     ],
-    packages=find_packages(where='..', include=['opinion_clob_sdk', 'opinion_clob_sdk.*']),
-    package_dir={'': '..'},
+    packages=[
+        'opinion_clob_sdk',
+        'opinion_clob_sdk.chain',
+        'opinion_clob_sdk.chain.contracts',
+        'opinion_clob_sdk.chain.py_order_utils',
+        'opinion_clob_sdk.chain.py_order_utils.builders',
+        'opinion_clob_sdk.chain.py_order_utils.model',
+        'opinion_clob_sdk.chain.safe',
+        'opinion_clob_sdk.chain.safe.eip712',
+        'opinion_clob_sdk.chain.safe.safe_contracts',
+    ],
+    package_dir={'opinion_clob_sdk': '.'},
     include_package_data=True,
     python_requires=">=3.8",
     classifiers=[

{opinion_clob_sdk-0.1.14 → opinion_clob_sdk-0.1.16}/tests/test_model.py

@@ -21,9 +21,9 @@ class TestEnums:
 
     def test_topic_status_filter_values(self):
         """Test TopicStatusFilter enum values"""
-        assert TopicStatusFilter.ALL.value == 0
-        assert TopicStatusFilter.ACTIVATED.value == 2
-        assert TopicStatusFilter.RESOLVED.value == 4
+        assert TopicStatusFilter.ALL.value is None  # Changed to None
+        assert TopicStatusFilter.ACTIVATED.value == "activated"  # Changed to string
+        assert TopicStatusFilter.RESOLVED.value == "resolved"  # Changed to string
 
     def test_enum_membership(self):
         """Test enum membership"""

{opinion_clob_sdk-0.1.14 → opinion_clob_sdk-0.1.16}/tests/test_order_calculations.py

@@ -49,7 +49,7 @@ class TestOrderCalculations:
         assert taker_amount == expected_taker
 
     def test_buy_order_high_price(self):
-        """Test buy order with high price (0.9)"""
+        """Test buy order with high price (0.9) - now with 4-digit precision"""
         price = 0.9
         maker_amount = 1000000000000000000
         side = BUY
@@ -62,18 +62,19 @@ class TestOrderCalculations:
             decimals=decimals
         )
 
-        # Due to rounding, recalculated_maker_amount may differ by a small amount
-        # This is expected when floor(maker/price) * price is calculated
-        # Allow up to 1 unit difference due to integer floor operations
-        assert abs(recalculated_maker_amount - maker_amount) <= 1
+        # With 4-digit precision, expect larger rounding differences
+        # The maker amount will be rounded to 4 significant digits
+        # Allow difference up to 10% due to 4-digit rounding
+        assert recalculated_maker_amount <= maker_amount
+        assert recalculated_maker_amount > 0
 
         # Verify taker amount is positive and reasonable
         assert taker_amount > 0
 
         # Verify the price relationship: for BUY orders, price = maker/taker
-        # Allow small rounding error
+        # Allow larger rounding error due to 4-digit precision
         actual_price = recalculated_maker_amount / taker_amount
-        assert abs(actual_price - price) < 0.001
+        assert abs(actual_price - price) < 0.1  # Increased tolerance for 4-digit precision
 
     def test_sell_order_low_price(self):
         """Test sell order with low price (0.1)"""

opinion_clob_sdk-0.1.16/tests/test_precision.py

@@ -0,0 +1,272 @@
+import pytest
+from decimal import Decimal
+from opinion_clob_sdk.chain.py_order_utils.utils import (
+    calculate_order_amounts,
+    round_to_significant_digits
+)
+from opinion_clob_sdk.chain.py_order_utils.model.sides import OrderSide
+
+
+class TestRoundToSignificantDigits:
+    """Test the round_to_significant_digits function"""
+
+    def test_round_to_4_digits(self):
+        """Test rounding to 4 significant digits"""
+        # 123456789 -> keep first 4 digits (1234) -> round 5 up -> 1235 -> 123500000
+        assert round_to_significant_digits(123456789, 4) == 123500000
+        # 10000000000000000000 has 2 significant digits, should stay the same
+        assert round_to_significant_digits(10000000000000000000, 4) == 10000000000000000000
+        # 12345 -> keep first 4 digits (1234) -> round 5 to nearest even -> 12340
+        result = round_to_significant_digits(12345, 4)
+        assert result in [12340, 12350]  # Python's round() uses banker's rounding
+        # 1234 has exactly 4 digits, should stay the same
+        assert round_to_significant_digits(1234, 4) == 1234
+
+    def test_round_to_6_digits(self):
+        """Test rounding to 6 significant digits"""
+        assert round_to_significant_digits(123456789, 6) == 123457000
+        assert round_to_significant_digits(10000000000000000000, 6) == 10000000000000000000
+        assert round_to_significant_digits(123456, 6) == 123456
+
+    def test_edge_cases(self):
+        """Test edge cases"""
+        assert round_to_significant_digits(0, 4) == 0
+        assert round_to_significant_digits(1, 4) == 1
+        assert round_to_significant_digits(999, 4) == 999
+        assert round_to_significant_digits(9999, 4) == 9999
+        assert round_to_significant_digits(10000, 4) == 10000
+
+    def test_large_numbers(self):
+        """Test with 18-decimal wei amounts"""
+        # 10 USDC = 10000000000000000000 wei
+        result = round_to_significant_digits(10000000000000000000, 4)
+        assert result == 10000000000000000000
+
+        # 42.553191 tokens = 42553191000000000000 wei
+        result = round_to_significant_digits(42553191000000000000, 4)
+        assert result == 42550000000000000000  # 4 significant digits: 4255
+
+
+class TestOrderCalculationPrecision:
+    """Test order calculations with 4-digit precision to avoid matching engine errors"""
+
+    def test_buy_order_10_usdc_at_0_27(self):
+        """
+        Test the exact case that was failing:
+        BUY 10 USDC @ 0.27 price
+
+        Expected behavior:
+        - maker_amount: 10 USDC = 10000000000000000000 wei
+        - Price should be EXACT when calculated from maker/taker
+        - No additional decimal places in the price
+        """
+        price = 0.27
+        maker_amount = 10000000000000000000  # 10 USDC
+        side = OrderSide.BUY
+
+        recalculated_maker, taker = calculate_order_amounts(
+            price=price,
+            maker_amount=maker_amount,
+            side=side,
+            decimals=18
+        )
+
+        # Check that maker is close to 4 significant digits (allow small deviation for exact price)
+        # The priority is EXACT price, not perfect 4-digit rounding
+        expected_4digit = round_to_significant_digits(maker_amount, 4)
+        # Allow up to 10% deviation from 4-digit target for price exactness
+        assert abs(recalculated_maker - expected_4digit) / expected_4digit < 0.1, \
+            f"Maker {recalculated_maker} too far from 4-digit target {expected_4digit}"
+
+        # Most importantly: verify that the calculated price is EXACT
+        calculated_price = Decimal(str(recalculated_maker)) / Decimal(str(taker))
+        price_decimal = Decimal(str(price))
+
+        # The calculated price should exactly match the input price
+        assert calculated_price == price_decimal, \
+            f"Price mismatch: expected {price_decimal}, got {calculated_price}"
+
+        # Ensure we don't exceed the original maker amount
+        assert recalculated_maker <= maker_amount
+
+    def test_buy_order_10_usdc_at_0_235(self):
+        """
+        Test BUY 10 USDC @ 0.235 price (another reported case)
+        """
+        price = 0.235
+        maker_amount = 10000000000000000000  # 10 USDC
+        side = OrderSide.BUY
+
+        recalculated_maker, taker = calculate_order_amounts(
+            price=price,
+            maker_amount=maker_amount,
+            side=side,
+            decimals=18
+        )
+
+        # Verify exact price match
+        calculated_price = Decimal(str(recalculated_maker)) / Decimal(str(taker))
+        price_decimal = Decimal(str(price))
+        assert calculated_price == price_decimal, \
+            f"Price mismatch: expected {price_decimal}, got {calculated_price}"
+
+    def test_sell_order_precision(self):
+        """Test SELL order price exactness"""
+        price = 0.5
+        maker_amount = 10000000000000000000  # 10 tokens
+        side = OrderSide.SELL
+
+        recalculated_maker, taker = calculate_order_amounts(
+            price=price,
+            maker_amount=maker_amount,
+            side=side,
+            decimals=18
+        )
+
+        # Verify exact price match for SELL: price = taker / maker
+        calculated_price = Decimal(str(taker)) / Decimal(str(recalculated_maker))
+        price_decimal = Decimal(str(price))
+        assert calculated_price == price_decimal, \
+            f"Price mismatch: expected {price_decimal}, got {calculated_price}"
+
+    def test_various_prices_buy_orders(self):
+        """Test BUY orders with various prices - ensure exact price match"""
+        test_cases = [
+            0.111,  # Should give exact 0.111, not 0.111000111
+            0.222,  # Should give exact 0.222, not fail
+            0.333,  # Should give exact 0.333
+            0.125,  # Should give exact 0.125
+            0.275,  # Should give exact 0.275
+            0.1,
+            0.25,
+            0.5,
+            0.75,
+            0.9,
+        ]
+
+        for price in test_cases:
+            recalculated_maker, taker = calculate_order_amounts(
+                price=price,
+                maker_amount=10000000000000000000,
+                side=OrderSide.BUY,
+                decimals=18
+            )
+
+            # Verify exact price match
+            calculated_price = Decimal(str(recalculated_maker)) / Decimal(str(taker))
+            price_decimal = Decimal(str(price))
+            assert calculated_price == price_decimal, \
+                f"Price {price}: expected {price_decimal}, got {calculated_price}"
+
+    def test_various_prices_sell_orders(self):
+        """Test SELL orders with various prices - ensure exact price match"""
+        test_cases = [
+            0.111,
+            0.222,
+            0.333,
+            0.125,
+            0.275,
+            0.1,
+            0.25,
+            0.5,
+            0.75,
+            0.9,
+        ]
+
+        for price in test_cases:
+            recalculated_maker, taker = calculate_order_amounts(
+                price=price,
+                maker_amount=10000000000000000000,
+                side=OrderSide.SELL,
+                decimals=18
+            )
+
+            # Verify exact price match
+            calculated_price = Decimal(str(taker)) / Decimal(str(recalculated_maker))
+            price_decimal = Decimal(str(price))
+            assert calculated_price == price_decimal, \
+                f"Price {price}: expected {price_decimal}, got {calculated_price}"
+
+    def test_price_validation(self):
+        """Test that invalid prices are rejected"""
+        with pytest.raises(ValueError, match="Price must be between"):
+            calculate_order_amounts(0.0, 10000000000000000000, OrderSide.BUY, 18)
+
+        with pytest.raises(ValueError, match="Price must be between"):
+            calculate_order_amounts(1.0, 10000000000000000000, OrderSide.BUY, 18)
+
+        with pytest.raises(ValueError, match="Price must be between"):
+            calculate_order_amounts(1.5, 10000000000000000000, OrderSide.BUY, 18)
+
+    def test_precision_limit_validation(self):
+        """Test that excessive price precision is rejected"""
+        # 7 decimal places should fail (max is 6)
+        with pytest.raises(ValueError, match="Price precision cannot exceed 6 decimal places"):
+            calculate_order_amounts(0.1234567, 10000000000000000000, OrderSide.BUY, 18)
+
+        # 6 decimal places should pass
+        recalculated_maker, taker = calculate_order_amounts(
+            0.123456, 10000000000000000000, OrderSide.BUY, 18
+        )
+        assert recalculated_maker > 0
+        assert taker > 0
+
+    def test_minimum_amount_enforcement(self):
+        """Test that calculated amounts are at least 1"""
+        # Small amounts should still produce valid results
+        price = 0.5
+        maker_amount = 100  # very small amount
+
+        recalculated_maker, taker = calculate_order_amounts(
+            price=price,
+            maker_amount=maker_amount,
+            side=OrderSide.BUY,
+            decimals=18
+        )
+
+        # Should be at least 1
+        assert recalculated_maker >= 1
+        assert taker >= 1
+
+    def test_no_overspending(self):
+        """Test that recalculated_maker never exceeds original maker_amount"""
+        test_cases = [
+            (0.27, 10000000000000000000),
+            (0.235, 10000000000000000000),
+            (0.5, 10000000000000000000),
+            (0.75, 10000000000000000000),
+        ]
+
+        for price, maker_amount in test_cases:
+            recalculated_maker, taker = calculate_order_amounts(
+                price=price,
+                maker_amount=maker_amount,
+                side=OrderSide.BUY,
+                decimals=18
+            )
+
+            # Should never exceed original amount
+            assert recalculated_maker <= maker_amount, \
+                f"Overspending detected: {recalculated_maker} > {maker_amount} at price {price}"
+
+    def test_calculated_price_within_bounds(self):
+        """Test that calculated price from amounts is within valid bounds"""
+        # Test reasonable prices that won't hit boundary validation issues
+        for price in [0.1, 0.27, 0.5, 0.75, 0.9]:
+            for side in [OrderSide.BUY, OrderSide.SELL]:
+                recalculated_maker, taker = calculate_order_amounts(
+                    price=price,
+                    maker_amount=10000000000000000000,
+                    side=side,
+                    decimals=18
+                )
+
+                # Calculate actual price from amounts
+                if side == OrderSide.BUY:
+                    actual_price = recalculated_maker / taker
+                else:
+                    actual_price = taker / recalculated_maker
+
+                # Should be within valid range with some tolerance
+                assert 0.001 <= actual_price <= 0.999, \
+                    f"Calculated price {actual_price} out of bounds for {side.name} at {price}"