opinion-clob-sdk 0.1.14__py3-none-any.whl → 0.1.16__py3-none-any.whl

opinion_clob_sdk/__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/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.14.dist-info → opinion_clob_sdk-0.1.16.dist-info}/METADATA

@@ -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.16.dist-info/RECORD

@@ -0,0 +1,47 @@
+opinion_clob_sdk/__init__.py,sha256=b-evEc0NpwKq63fZMKvxFbd7coqJ7o5oWsy_ZcgK5MU,625
+opinion_clob_sdk/config.py,sha256=JoQvyK5IAnPiwwB8YZsmUtdEr-5hW2YG6iz1pOnLvDk,139
+opinion_clob_sdk/model.py,sha256=eqNkEdyJPmcL_wax8ieybeyhR40JwGDB_KPplXLmNxE,309
+opinion_clob_sdk/sdk.py,sha256=SO-7Hmr3K7pmdGm4JKqJPbvtnl4GBOxSAOVNm_2KDyw,39499
+opinion_clob_sdk/verify_api_calls.py,sha256=MU4NEyfQ5hDmFJ0lT8g7KXVdlZ0cBtFyBTCbhhfI6a4,5031
+opinion_clob_sdk/chain/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+opinion_clob_sdk/chain/contract_caller.py,sha256=AKCD1ZvLTbJX_YWFJecRtZ4Pi7L3_20Q7YOSGfAolEY,17148
+opinion_clob_sdk/chain/exception.py,sha256=6SSx4T_WZL8BxzRbfGSDp6eGD4zJ5ACeBB58DlrpmoA,234
+opinion_clob_sdk/chain/contracts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+opinion_clob_sdk/chain/contracts/conditional_tokens.py,sha256=P_MpetUKMNnT_hchZ0A9q7-g_ZKjkOr-BLldPXB4J7o,13998
+opinion_clob_sdk/chain/contracts/erc20.py,sha256=C56GdZeMxcgdJTmMQKSfA8xHzDdNT71SaNf6xhJIVMY,2843
+opinion_clob_sdk/chain/py_order_utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+opinion_clob_sdk/chain/py_order_utils/constants.py,sha256=afsZ0OahGbCzNPE2rXKU1k8gQymkh4ODLKh4KPklvnA,70
+opinion_clob_sdk/chain/py_order_utils/signer.py,sha256=NAMHcMREbRUgrz1-28sqpPoMD8LkRJSyUn7-FLUkYsM,447
+opinion_clob_sdk/chain/py_order_utils/utils.py,sha256=rrdtPW2T5raF0TntKVrR9RVz6XkkRWhiaWHPaGHMtrg,6193
+opinion_clob_sdk/chain/py_order_utils/builders/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+opinion_clob_sdk/chain/py_order_utils/builders/base_builder.py,sha256=lw925Mz6MerqCyXNgonhNP-495gZPm_me4HtlhyhVHM,1272
+opinion_clob_sdk/chain/py_order_utils/builders/exception.py,sha256=525fSH8Q241VjxdllBkWi3DiW_-6I1AmG-iHwZBTp4E,47
+opinion_clob_sdk/chain/py_order_utils/builders/order_builder.py,sha256=NybKbNhRd1jceSjtp6lL9x1DjDzJ4ClhsAK2zS58P4c,2968
+opinion_clob_sdk/chain/py_order_utils/builders/order_builder_test.py,sha256=0xPLO9rEDsw_s3UQiooquEarvFe8KneafiaY6PgkLIo,1773
+opinion_clob_sdk/chain/py_order_utils/model/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+opinion_clob_sdk/chain/py_order_utils/model/order.py,sha256=fI2NhqX_cdUmZivliki4rHXJCxQQY5ykjh8a58FFfPE,5852
+opinion_clob_sdk/chain/py_order_utils/model/order_type.py,sha256=kYXJ0Ikk3Qnr00yCIfrtJibFve8DUjNSJ_xiLw7IphY,185
+opinion_clob_sdk/chain/py_order_utils/model/sides.py,sha256=FZVZnutyLmgiNCVoz-1fjxxFzhH3z24xy5BY6pkIfs8,177
+opinion_clob_sdk/chain/py_order_utils/model/signatures.py,sha256=lKoqi7gVay9NjCv_2QTdelP4EFy61Ez0UeY1ytOmooM,224
+opinion_clob_sdk/chain/safe/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+opinion_clob_sdk/chain/safe/constants.py,sha256=H4UKUXJxR9pvwRHU4WM1p6wZ6yGjApOpWfEMYj-W_iE,572
+opinion_clob_sdk/chain/safe/enums.py,sha256=aP9-PfC97ZYtX0dKOYKAyxITVrCDMIAY2_mHMdU8IJM,90
+opinion_clob_sdk/chain/safe/exceptions.py,sha256=kp0jfnP93JyEkEgwPERL6MZ9D8ozbioURcKjMwSLjgE,1498
+opinion_clob_sdk/chain/safe/multisend.py,sha256=l-lWlb7jSzmNCyFbpAr-d8SYEKM4QRm_h0tF53T3CzE,12659
+opinion_clob_sdk/chain/safe/safe.py,sha256=OO-010or-qCCwCSTSh4qKGmoSwEsL2IYECW8IYmSmKQ,5216
+opinion_clob_sdk/chain/safe/safe_signature.py,sha256=W1Xn73DSzE3PZ6ITyikhdWhosY3wdey-scX0Jci037I,12559
+opinion_clob_sdk/chain/safe/safe_test.py,sha256=pbCYOLa_6cQbC0KOA7t41ItunauhHfgN7uneENfMXPk,1384
+opinion_clob_sdk/chain/safe/safe_tx.py,sha256=QxKzv0EA7uwjakFMDVoDLrzYlZANpEhblPBQ7ZcF9zE,17211
+opinion_clob_sdk/chain/safe/signatures.py,sha256=8l6t6R21E9Mj4_USagIp1GiUlJmAp0Cqq9VpB7Zk960,1978
+opinion_clob_sdk/chain/safe/typing.py,sha256=wytgXXRbpyccM_HxpQLeDzfo40Ch_K-Z_ivORb-eNZo,419
+opinion_clob_sdk/chain/safe/utils.py,sha256=1u4yKwMCvfOlg9NsWbsM2WszQoO1wd6D2Z2aGAb1jjo,6469
+opinion_clob_sdk/chain/safe/eip712/__init__.py,sha256=ge0S6t2RtFc_mLFr4D93l6WLS2EONKgkuPGkcP_nDJ4,5915
+opinion_clob_sdk/chain/safe/safe_contracts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+opinion_clob_sdk/chain/safe/safe_contracts/compatibility_fallback_handler_v1_3_0.py,sha256=_aENMzhiQgKSzXxn-TnVFWE84lIgDv1Iiw-VdIC1IMw,5968
+opinion_clob_sdk/chain/safe/safe_contracts/multisend_v1_3_0.py,sha256=8oGhNkS2k2Cy5pG6YNt_BKytS3AEtPeXv4rkyXv_p0M,380
+opinion_clob_sdk/chain/safe/safe_contracts/safe_v1_3_0.py,sha256=YCUWTpf_pR44iUUkDl42f3n2YXSVGlTBcvMtReN7rlM,21922
+opinion_clob_sdk/chain/safe/safe_contracts/utils.py,sha256=xnW8JSq8tVMfvZ4lhT-L96P3Usjs2zrZ5jzrNZvFHjc,631
+opinion_clob_sdk-0.1.16.dist-info/METADATA,sha256=tuIThQ-ZhxsKUChEvOrk4xWt0ppdUdnSAVtGvL7W0EY,2777
+opinion_clob_sdk-0.1.16.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+opinion_clob_sdk-0.1.16.dist-info/top_level.txt,sha256=4gH76GRX1WZSc3b146FfxE6BAxggJD8y3NMEHUOSPA0,17
+opinion_clob_sdk-0.1.16.dist-info/RECORD,,

opinion_clob_sdk/opinion_clob_sdk/__init__.py

@@ -1,26 +0,0 @@
-"""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.14"
-__all__ = [
-    "Client",
-    "TopicStatus",
-    "TopicType",
-    "TopicStatusFilter",
-    "CHAIN_ID_BASE_MAINNET",
-    "SUPPORTED_CHAIN_IDS",
-    "BalanceNotEnough",
-    "NoPositionsToRedeem",
-    "InsufficientGasBalance"
-]

opinion_clob_sdk/opinion_clob_sdk/chain/contract_caller.py

@@ -1,390 +0,0 @@
-from typing import List, Any
-import time
-import logging
-
-from eth_typing import HexStr, ChecksumAddress, Hash32
-from hexbytes import HexBytes
-from web3 import Web3
-from web3.contract import Contract
-from web3.providers import HTTPProvider
-
-from .exception import BalanceNotEnough, NoPositionsToRedeem, InsufficientGasBalance
-from .safe.constants import NULL_HASH
-from .safe.multisend import MultiSendTx, MultiSendOperation
-from .safe.safe import Safe
-from .py_order_utils.signer import Signer
-from .safe.utils import get_empty_tx_params
-
-
-class ContractCaller:
-    def __init__(self, rpc_url='', private_key: HexStr = '', multi_sig_addr: ChecksumAddress = '',
-                 conditional_tokens_addr: ChecksumAddress = '', multisend_addr: ChecksumAddress = '',
-                 enable_trading_check_interval=3600):
-        """
-        Initialize ContractCaller for blockchain interactions.
-
-        Args:
-            rpc_url: RPC endpoint URL
-            private_key: Private key for signing transactions
-            multi_sig_addr: Multi-signature wallet address
-            conditional_tokens_addr: Conditional tokens contract address
-            multisend_addr: Multisend contract address
-            enable_trading_check_interval: Time interval (in seconds) to cache enable_trading checks.
-                Default is 3600 (1 hour). Within this interval, enable_trading() will return
-                immediately without checking blockchain state, improving performance significantly.
-        """
-        self.private_key = private_key
-        self.signer = Signer(self.private_key)
-
-        self.multi_sig_addr = multi_sig_addr
-        self.conditional_tokens_addr = conditional_tokens_addr
-        self.multisend_addr = multisend_addr
-        w3 = Web3(HTTPProvider(rpc_url))
-        self.w3 = w3
-        self.safe = Safe(w3, private_key, multi_sig_addr, multisend_addr)
-        self.__enable_trading_check_interval: int = enable_trading_check_interval
-        self.__enable_trading_last_time: float = None
-        # Cache for token decimals to avoid repeated contract calls
-        self._token_decimals_cache: dict = {}
-
-    @property
-    def conditional_tokens(self) -> Contract:
-        from .contracts.conditional_tokens import abi
-        return self.w3.eth.contract(self.conditional_tokens_addr, abi=abi)
-
-    def get_erc20_contract(self, address: ChecksumAddress):
-        from .contracts.erc20 import abi
-        return self.w3.eth.contract(address, abi=abi)
-
-    def get_token_decimals(self, token_address: ChecksumAddress) -> int:
-        """Get token decimals with caching to avoid repeated contract calls"""
-        token_key = token_address.lower()
-
-        if token_key not in self._token_decimals_cache:
-            erc20_contract = self.get_erc20_contract(token_address)
-            try:
-                decimals = erc20_contract.functions.decimals().call()
-                self._token_decimals_cache[token_key] = decimals
-                logging.info(f'Token {token_address} uses {decimals} decimals')
-            except Exception as e:
-                logging.warning(f'Failed to get decimals for {token_address}, defaulting to 18: {e}')
-                # Default to 18 if call fails (standard for most tokens)
-                decimals = 18
-                self._token_decimals_cache[token_key] = decimals
-
-        return self._token_decimals_cache[token_key]
-
-    def check_gas_balance(self, estimated_gas: int = 500000) -> None:
-        """
-        Check if signer has enough gas tokens (ETH) to execute transaction.
-
-        Args:
-            estimated_gas: Estimated gas units needed (default: 500000)
-
-        Raises:
-            InsufficientGasBalance: If signer doesn't have enough ETH for gas
-        """
-        signer_address = self.signer.address()
-        gas_balance = self.w3.eth.get_balance(signer_address)
-
-        # Get current gas price with safety margin
-        base_fee = self.w3.eth.get_block('latest').get('baseFeePerGas', 0)
-
-        # For EIP-1559 chains, calculate max fee
-        if base_fee > 0:
-            # Priority fee (tip) - typically 1-2 gwei on Base
-            max_priority_fee = self.w3.to_wei(2, 'gwei')
-            # Max fee = base fee * 2 + priority fee (allows for 2x base fee increase)
-            max_fee_per_gas = (base_fee * 2) + max_priority_fee
-            gas_price = max_fee_per_gas
-        else:
-            # Fallback for legacy transactions
-            gas_price = self.w3.eth.gas_price
-
-        # Add 20% safety margin to estimated gas
-        estimated_gas_with_margin = int(estimated_gas * 1.2)
-
-        # Calculate required ETH (gas * gas_price)
-        required_eth = estimated_gas_with_margin * gas_price
-
-        if gas_balance < required_eth:
-            gas_balance_eth = self.w3.from_wei(gas_balance, 'ether')
-            required_eth_formatted = self.w3.from_wei(required_eth, 'ether')
-            gas_price_gwei = self.w3.from_wei(gas_price, 'gwei')
-            raise InsufficientGasBalance(
-                f"Insufficient gas balance. Signer {signer_address} has {gas_balance_eth} ETH, "
-                f"but needs approximately {required_eth_formatted} ETH for gas "
-                f"(gas: {estimated_gas_with_margin}, price: {gas_price_gwei} gwei)"
-            )
-
-        logging.info(
-            f"Gas balance check passed. Signer has {self.w3.from_wei(gas_balance, 'ether')} ETH, "
-            f"estimated cost: {self.w3.from_wei(required_eth, 'ether')} ETH "
-            f"(gas: {estimated_gas_with_margin}, price: {self.w3.from_wei(gas_price, 'gwei')} gwei)"
-        )
-
-    def estimate_transaction_gas(self, tx_params: dict) -> int:
-        """
-        Estimate gas for a transaction using web3's gas estimation.
-
-        Args:
-            tx_params: Transaction parameters dict with 'from', 'to', 'data', etc.
-
-        Returns:
-            Estimated gas units needed
-        """
-        try:
-            estimated = self.w3.eth.estimate_gas(tx_params)
-            logging.debug(f"Estimated gas for transaction: {estimated}")
-            return estimated
-        except Exception as e:
-            logging.warning(f"Gas estimation failed, using fallback: {e}")
-            # Fallback to conservative estimate
-            return 500000
-
-
-    def split(self, collateral_token: ChecksumAddress, condition_id: Hash32,
-              amount: int, partition: list = [1, 2], parent_collection_id: Hash32 = NULL_HASH) -> tuple[HexBytes, HexBytes, Any]:
-
-        # Check gas balance before executing transaction
-        self.check_gas_balance(estimated_gas=300000)
-
-        # Check balance of collateral
-        balance = self.get_erc20_contract(collateral_token).functions \
-            .balanceOf(self.multi_sig_addr).call()
-        logging.info(f'Collateral balance: {balance}')
-        if balance < amount:
-            raise BalanceNotEnough()
-
-        multi_send_txs: List[MultiSendTx] = []
-
-        data = HexBytes(
-            self.conditional_tokens.functions.splitPosition(
-                collateral_token, parent_collection_id, condition_id, partition, amount
-            ).build_transaction(get_empty_tx_params())["data"]
-        )
-
-        multi_send_txs.append(MultiSendTx(
-            operation=MultiSendOperation.CALL.value,
-            to=self.conditional_tokens_addr,
-            value=0,
-            data=data,
-        ))
-
-        tx_hash, safe_tx_hash, return_value = self.safe.execute_multisend(multi_send_txs)
-
-        # Validate transaction was successful
-        receipt = self.w3.eth.wait_for_transaction_receipt(tx_hash, timeout=120)
-        if receipt['status'] != 1:
-            raise Exception(f"Split transaction failed. Transaction hash: {tx_hash.hex()}")
-
-        logging.info(f"Split successful. Transaction hash: {tx_hash.hex()}")
-        return tx_hash, safe_tx_hash, return_value
-
-    def merge(self, collateral_token: ChecksumAddress, condition_id: Hash32,
-              amount: int, partition: list = [1, 2], parent_collection_id: Hash32 = NULL_HASH) -> tuple[HexBytes, HexBytes, Any]:
-
-        # Check gas balance before executing transaction
-        self.check_gas_balance(estimated_gas=300000)
-
-        # Check balance of positions
-        for index_set in partition:
-            position_id = self.get_position_id(condition_id, index_set=index_set, collateral_token=collateral_token)
-            balance = self.conditional_tokens.functions \
-                .balanceOf(self.multi_sig_addr, position_id).call()
-            # print('balance: {}'.format(balance))
-            if balance < amount:
-                raise BalanceNotEnough()
-
-        multi_send_txs: List[MultiSendTx] = []
-
-        data = HexBytes(
-            self.conditional_tokens.functions.mergePositions(
-                collateral_token, parent_collection_id, condition_id, partition, amount
-            ).build_transaction(get_empty_tx_params())["data"]
-        )
-
-        multi_send_txs.append(MultiSendTx(
-            operation=MultiSendOperation.CALL.value,
-            to=self.conditional_tokens_addr,
-            value=0,
-            data=data,
-        ))
-
-        tx_hash, safe_tx_hash, return_value = self.safe.execute_multisend(multi_send_txs)
-
-        # Validate transaction was successful
-        receipt = self.w3.eth.wait_for_transaction_receipt(tx_hash, timeout=120)
-        if receipt['status'] != 1:
-            raise Exception(f"Merge transaction failed. Transaction hash: {tx_hash.hex()}")
-
-        logging.info(f"Merge successful. Transaction hash: {tx_hash.hex()}")
-        return tx_hash, safe_tx_hash, return_value
-
-    def redeem(self, collateral_token: ChecksumAddress, condition_id: Hash32,
-              partition: list = [1, 2], parent_collection_id: Hash32 = NULL_HASH) -> tuple[HexBytes, HexBytes, Any]:
-
-        # Check gas balance before executing transaction
-        self.check_gas_balance(estimated_gas=300000)
-
-        # Check balance of positions
-        has_positions = False
-        for index_set in partition:
-            position_id = self.get_position_id(condition_id, index_set=index_set, collateral_token=collateral_token)
-            balance = self.conditional_tokens.functions \
-                .balanceOf(self.multi_sig_addr, position_id).call()
-            # print('balance: {}'.format(balance))
-            if balance > 0:
-                has_positions = True
-                break
-
-        if not has_positions:
-            raise NoPositionsToRedeem
-
-        multi_send_txs: List[MultiSendTx] = []
-
-        data = HexBytes(
-            self.conditional_tokens.functions.redeemPositions(
-                collateral_token, parent_collection_id, condition_id, partition
-            ).build_transaction(get_empty_tx_params())["data"]
-        )
-
-        multi_send_txs.append(MultiSendTx(
-            operation=MultiSendOperation.CALL.value,
-            to=self.conditional_tokens_addr,
-            value=0,
-            data=data,
-        ))
-
-        tx_hash, safe_tx_hash, return_value = self.safe.execute_multisend(multi_send_txs)
-
-        # Validate transaction was successful
-        receipt = self.w3.eth.wait_for_transaction_receipt(tx_hash, timeout=120)
-        if receipt['status'] != 1:
-            raise Exception(f"Redeem transaction failed. Transaction hash: {tx_hash.hex()}")
-
-        logging.info(f"Redeem successful. Transaction hash: {tx_hash.hex()}")
-        return tx_hash, safe_tx_hash, return_value
-
-    def enable_trading(self, supported_quote_tokens: dict) -> tuple[HexBytes, HexBytes, Any]:
-        if self.__enable_trading_last_time is not None and \
-                time.time() - self.__enable_trading_last_time < self.__enable_trading_check_interval:
-            return HexBytes(b'0x'), HexBytes(b'0x'), None
-
-        self.__enable_trading_last_time = time.time()
-
-        # Check gas balance before executing transaction (approve operations can be gas-heavy)
-        self.check_gas_balance(estimated_gas=500000)
-
-        multi_send_txs: List[MultiSendTx] = []
-
-        from .contracts.erc20 import abi
-        for erc20_address, ctf_exchange_address in supported_quote_tokens.items():
-            erc20_contract = self.w3.eth.contract(erc20_address, abi=abi)
-            allowance = erc20_contract.functions.allowance(self.multi_sig_addr, ctf_exchange_address).call()
-
-            # Get actual token decimals from contract
-            decimals = self.get_token_decimals(erc20_address)
-
-            # Used for trading on ctf_exchange
-            min_threshold = 1000000000 * 10**decimals
-            allowance_to_update = 2*1000000000 * 10**decimals
-            if allowance < min_threshold:
-                # DH1 Fix: Reset approval to 0 first (required for some tokens like USDT)
-                # to prevent approval race condition attack
-                if allowance > 0:
-                    reset_data = HexBytes(
-                        erc20_contract.functions.approve(
-                            ctf_exchange_address, 0
-                        ).build_transaction(get_empty_tx_params())["data"]
-                    )
-                    multi_send_txs.append(MultiSendTx(
-                        operation=MultiSendOperation.CALL.value,
-                        to=erc20_address,
-                        value=0,
-                        data=reset_data,
-                    ))
-                    logging.info(f'Resetting approval to 0 for {erc20_address} -> {ctf_exchange_address}')
-
-                # Now set the new approval amount
-                data = HexBytes(
-                    erc20_contract.functions.approve(
-                        ctf_exchange_address, allowance_to_update
-                    ).build_transaction(get_empty_tx_params())["data"]
-                )
-
-                multi_send_txs.append(MultiSendTx(
-                    operation=MultiSendOperation.CALL.value,
-                    to=erc20_address,
-                    value=0,
-                    data=data,
-                ))
-
-            # Used for splitting
-            allowance = erc20_contract.functions.allowance(self.multi_sig_addr, self.conditional_tokens_addr).call()
-            if allowance < min_threshold:
-                # DH1 Fix: Reset approval to 0 first (required for some tokens like USDT)
-                if allowance > 0:
-                    reset_data = HexBytes(
-                        erc20_contract.functions.approve(
-                            self.conditional_tokens_addr, 0
-                        ).build_transaction(get_empty_tx_params())["data"]
-                    )
-                    multi_send_txs.append(MultiSendTx(
-                        operation=MultiSendOperation.CALL.value,
-                        to=erc20_address,
-                        value=0,
-                        data=reset_data,
-                    ))
-                    logging.info(f'Resetting approval to 0 for {erc20_address} -> {self.conditional_tokens_addr}')
-
-                # Now set the new approval amount
-                data = HexBytes(
-                    erc20_contract.functions.approve(
-                        self.conditional_tokens_addr, allowance_to_update
-                    ).build_transaction(get_empty_tx_params())["data"]
-                )
-
-                multi_send_txs.append(MultiSendTx(
-                    operation=MultiSendOperation.CALL.value,
-                    to=erc20_address,
-                    value=0,
-                    data=data,
-                ))
-
-            # Approve ctf_exchange for using conditional tokens
-            is_approved_for_all = self.conditional_tokens.functions.isApprovedForAll(
-                self.multi_sig_addr, ctf_exchange_address).call()
-            if is_approved_for_all is False:
-                data = HexBytes(
-                    self.conditional_tokens.functions.setApprovalForAll(
-                        ctf_exchange_address, True
-                    ).build_transaction(get_empty_tx_params())["data"]
-                )
-
-                multi_send_txs.append(MultiSendTx(
-                    operation=MultiSendOperation.CALL.value,
-                    to=self.conditional_tokens_addr,
-                    value=0,
-                    data=data,
-                ))
-
-        if len(multi_send_txs) > 0:
-            tx_hash, safe_tx_hash, return_value = self.safe.execute_multisend(multi_send_txs)
-
-            # Validate transaction was successful
-            receipt = self.w3.eth.wait_for_transaction_receipt(tx_hash, timeout=120)
-            if receipt['status'] != 1:
-                raise Exception(f"Enable trading transaction failed. Transaction hash: {tx_hash.hex()}")
-
-            logging.info(f"Enable trading successful. Transaction hash: {tx_hash.hex()}")
-            return tx_hash, safe_tx_hash, return_value
-        else:
-            return HexBytes(b'0x'), HexBytes(b'0x'), None
-
-    def get_position_id(self, condition_id: Hash32, index_set: int, collateral_token: ChecksumAddress,
-                        parent_condition_id=NULL_HASH):
-        collection_id = self.conditional_tokens.functions.getCollectionId(
-            parent_condition_id, condition_id, index_set).call()
-
-        return self.conditional_tokens.functions.getPositionId(collateral_token, collection_id).call()