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

opinion_clob_sdk/sdk.py

@@ -17,8 +17,9 @@ from .chain.py_order_utils.constants import ZERO_ADDRESS, ZX
 from .chain.py_order_utils.model.signatures import POLY_GNOSIS_SAFE
 from .chain.py_order_utils.model.sides import BUY, SELL, OrderSide
 from .chain.py_order_utils.model.order_type import LIMIT_ORDER, MARKET_ORDER
-from .model import TopicStatus, TopicStatusFilter, TopicType
+from .model import TopicStatus, TopicStatusFilter, TopicType, TopicSortType
 from .chain.py_order_utils.utils import calculate_order_amounts
+from .config import DEFAULT_CONTRACT_ADDRESSES
 
 API_INTERNAL_ERROR_MSG = "Unable to process your request. Please contact technical support."
 MISSING_MARKET_ID_MSG = "market_id is required."
@@ -26,8 +27,8 @@ MISSING_TOKEN_ID_MSG = "token_id is required."
 MAX_DECIMALS = 18  # Standard maximum for ERC20 tokens (ETH, DAI, etc.)
 
 # Supported blockchain chain IDs
-CHAIN_ID_BASE_MAINNET = 8453  # Base mainnet
-SUPPORTED_CHAIN_IDS = [CHAIN_ID_BASE_MAINNET]
+CHAIN_ID_BNB_MAINNET = 56  # BNB Chain (BSC) mainnet
+SUPPORTED_CHAIN_IDS = [CHAIN_ID_BNB_MAINNET]
 
 class InvalidParamError(Exception):
     pass
@@ -82,8 +83,9 @@ class Client:
         rpc_url: str = '',
         private_key: HexStr = HexStr(''),
         multi_sig_addr: str = '',
-        conditional_tokens_addr: ChecksumAddress = ChecksumAddress(''),
-        multisend_addr: ChecksumAddress = ChecksumAddress(''),
+        conditional_tokens_addr: Optional[ChecksumAddress] = None,
+        multisend_addr: Optional[ChecksumAddress] = None,
+        fee_manager_addr: Optional[ChecksumAddress] = None,
         enable_trading_check_interval: int = 3600,
         quote_tokens_cache_ttl: int = 3600,
         market_cache_ttl: int = 300
@@ -94,12 +96,13 @@ class Client:
         Args:
             host: API host URL
             apikey: API authentication key
-            chain_id: Blockchain chain ID (8453 for Base mainnet)
+            chain_id: Blockchain chain ID (56 for BNB Chain mainnet)
             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
+            conditional_tokens_addr: Conditional tokens contract address (optional, uses default if not provided)
+            multisend_addr: Multisend contract address (optional, uses default if not provided)
+            fee_manager_addr: Fee manager contract address (optional, uses default if not provided)
             enable_trading_check_interval: Time interval (in seconds) to cache enable_trading checks.
                 Default is 3600 (1 hour). Set to 0 to check every time.
                 This significantly improves performance for frequent operations.
@@ -108,6 +111,25 @@ class Client:
             market_cache_ttl: Time interval (in seconds) to cache market data.
                 Default is 300 (5 minutes). Set to 0 to disable caching.
         """
+        # Validate and set chain_id first
+        if chain_id not in SUPPORTED_CHAIN_IDS:
+            raise InvalidParamError(f'chain_id must be one of {SUPPORTED_CHAIN_IDS}')
+        self.chain_id = chain_id
+
+        # Use default contract addresses if not provided
+        if conditional_tokens_addr is None:
+            conditional_tokens_addr = ChecksumAddress(
+                DEFAULT_CONTRACT_ADDRESSES[chain_id]["conditional_tokens"]
+            )
+        if multisend_addr is None:
+            multisend_addr = ChecksumAddress(
+                DEFAULT_CONTRACT_ADDRESSES[chain_id]["multisend"]
+            )
+        if fee_manager_addr is None:
+            fee_manager_addr = ChecksumAddress(
+                DEFAULT_CONTRACT_ADDRESSES[chain_id]["fee_manager"]
+            )
+
         self.conf = Configuration(host=host)
         self.conf.api_key['ApiKeyAuth'] = apikey
         self.api_key = apikey
@@ -115,14 +137,11 @@ class Client:
         self.contract_caller = ContractCaller(rpc_url=rpc_url, private_key=private_key, multi_sig_addr=multi_sig_addr,
                                               conditional_tokens_addr=conditional_tokens_addr,
                                               multisend_addr=multisend_addr,
+                                              fee_manager_addr=fee_manager_addr,
                                               enable_trading_check_interval=enable_trading_check_interval)
         self.api_client = ApiClient(self.conf)
         self.market_api = PredictionMarketApi(self.api_client)
         self.user_api = UserApi(self.api_client)
-        # Validate and set chain_id
-        if chain_id not in SUPPORTED_CHAIN_IDS:
-            raise InvalidParamError(f'chain_id must be one of {SUPPORTED_CHAIN_IDS}')
-        self.chain_id = chain_id
 
         # Cache configuration
         self.quote_tokens_cache_ttl = quote_tokens_cache_ttl
@@ -151,7 +170,40 @@ class Client:
 
         return response.result.list
 
-    def enable_trading(self) -> Tuple[Any, Any, Any]:
+    def _format_transaction_result(self, tx_hash: Any, safe_tx_hash: Any, return_value: Any) -> Tuple[str, str, Optional[str]]:
+        """Convert transaction result to JSON-serializable format
+
+        Args:
+            tx_hash: Transaction hash (HexBytes or similar)
+            safe_tx_hash: Safe transaction hash (HexBytes or similar)
+            return_value: Contract call return value (bytes or similar)
+
+        Returns:
+            Tuple of (tx_hash_hex, safe_tx_hash_hex, return_value_hex)
+            where all values are hex strings or None
+        """
+        # Convert tx_hash to hex string
+        tx_hash_hex = tx_hash.hex() if hasattr(tx_hash, 'hex') and tx_hash else None
+
+        # Convert safe_tx_hash to hex string
+        safe_tx_hash_hex = safe_tx_hash.hex() if hasattr(safe_tx_hash, 'hex') and safe_tx_hash else None
+
+        # Convert return_value (bytes) to hex string
+        return_value_hex = None
+        if return_value is not None:
+            if hasattr(return_value, 'hex'):
+                return_value_hex = return_value.hex()
+            elif isinstance(return_value, bytes):
+                return_value_hex = '0x' + return_value.hex()
+
+        return tx_hash_hex, safe_tx_hash_hex, return_value_hex
+
+    def enable_trading(self) -> Tuple[Optional[str], Optional[str], Optional[str]]:
+        """Enable trading by approving necessary tokens.
+
+        Returns:
+            Tuple of (tx_hash, safe_tx_hash, return_value) as hex strings
+        """
         quote_token_list_response = self.get_quote_tokens()
         quote_token_list = self._parse_list_response(quote_token_list_response, "get quote tokens")
 
@@ -166,98 +218,141 @@ class Client:
         logging.info(f'Supported quote tokens: {supported_quote_tokens}')
         if len(supported_quote_tokens) == 0:
             raise OpenApiError('No supported quote tokens found')
-        return self.contract_caller.enable_trading(supported_quote_tokens)
+        tx_hash, safe_tx_hash, return_value = self.contract_caller.enable_trading(supported_quote_tokens)
+        return self._format_transaction_result(tx_hash, safe_tx_hash, return_value)
 
-    def split(self, market_id: int, amount: int, check_approval: bool = True) -> Tuple[Any, Any, Any]:
+    def split(self, market_id: int, amount: int, check_approval: bool = True) -> Tuple[Optional[str], Optional[str], Optional[str]]:
         """Split collateral into outcome tokens for a market.
 
         Args:
             market_id: The market ID to split tokens for (required)
             amount: Amount of collateral to split in wei (required)
             check_approval: Whether to check and enable trading approvals first
+
+        Returns:
+            Tuple of (tx_hash, safe_tx_hash, return_value) as hex strings
         """
-        if not market_id or market_id <= 0:
-            raise InvalidParamError("market_id must be a positive integer")
-        if not amount or amount <= 0:
-            raise InvalidParamError("amount must be a positive integer")
+        try:
+            if not market_id or market_id <= 0:
+                raise InvalidParamError("market_id must be a positive integer")
+            if not amount or amount <= 0:
+                raise InvalidParamError("amount must be a positive integer")
 
-        # Enable trading first for all trade operations.
-        if check_approval:
-            self.enable_trading()
+            # Enable trading first for all trade operations.
+            if check_approval:
+                self.enable_trading()
 
-        topic_detail = self.get_market(market_id)
-        market_data = self._validate_market_response(topic_detail, "get market for split")
+            topic_detail = self.get_market(market_id)
+            market_data = self._validate_market_response(topic_detail, "get market for split")
 
-        if int(market_data.chain_id) != self.chain_id:
-            raise OpenApiError('Cannot split on different chain')
+            if int(market_data.chain_id) != self.chain_id:
+                raise OpenApiError('Cannot split on different chain')
 
-        status = market_data.status
-        if not (status == TopicStatus.ACTIVATED.value or status == TopicStatus.RESOLVED.value or status == TopicStatus.RESOLVING.value):
-            raise OpenApiError('Cannot split on non-activated/resolving/resolved market')
-        collateral = fast_to_checksum_address(market_data.quote_token)
-        condition_id = market_data.condition_id
+            status = market_data.status
+            if not (status == TopicStatus.ACTIVATED.value or status == TopicStatus.RESOLVED.value or status == TopicStatus.RESOLVING.value):
+                raise OpenApiError('Cannot split on non-activated/resolving/resolved market')
+            collateral = fast_to_checksum_address(market_data.quote_token)
+            condition_id = market_data.condition_id
 
-        return self.contract_caller.split(collateral_token=collateral, condition_id=bytes.fromhex(condition_id), amount=amount)
+            tx_hash, safe_tx_hash, return_value = self.contract_caller.split(collateral_token=collateral, condition_id=bytes.fromhex(condition_id), amount=amount)
+            return self._format_transaction_result(tx_hash, safe_tx_hash, return_value)
+        except InvalidParamError as e:
+            logging.error(f"Validation error in split: {e}")
+            raise
+        except OpenApiError as e:
+            logging.error(f"API error in split: {e}")
+            raise
+        except Exception as e:
+            logging.error(f"Unexpected error in split: {e}")
+            raise OpenApiError(f"Failed to split collateral: {e}")
 
-    def merge(self, market_id: int, amount: int, check_approval: bool = True) -> Tuple[Any, Any, Any]:
+    def merge(self, market_id: int, amount: int, check_approval: bool = True) -> Tuple[Optional[str], Optional[str], Optional[str]]:
         """Merge outcome tokens back into collateral for a market.
 
         Args:
             market_id: The market ID to merge tokens for (required)
             amount: Amount of outcome tokens to merge in wei (required)
             check_approval: Whether to check and enable trading approvals first
-        """
-        if not market_id or market_id <= 0:
-            raise InvalidParamError("market_id must be a positive integer")
-        if not amount or amount <= 0:
-            raise InvalidParamError("amount must be a positive integer")
-
-        # Enable trading first for all trade operations.
-        if check_approval:
-            self.enable_trading()
-
-        topic_detail = self.get_market(market_id)
-        market_data = self._validate_market_response(topic_detail, "get market for merge")
-
-        if int(market_data.chain_id) != self.chain_id:
-            raise OpenApiError('Cannot merge on different chain')
-
-        status = market_data.status
-        if not (status == TopicStatus.ACTIVATED.value or status == TopicStatus.RESOLVED.value or status == TopicStatus.RESOLVING.value):
-            raise OpenApiError('Cannot merge on non-activated/resolving/resolved market')
-        collateral = fast_to_checksum_address(market_data.quote_token)
-        condition_id = market_data.condition_id
 
-        return self.contract_caller.merge(collateral_token=collateral, condition_id=bytes.fromhex(condition_id),
-                                          amount=amount)
+        Returns:
+            Tuple of (tx_hash, safe_tx_hash, return_value) as hex strings
+        """
+        try:
+            if not market_id or market_id <= 0:
+                raise InvalidParamError("market_id must be a positive integer")
+            if not amount or amount <= 0:
+                raise InvalidParamError("amount must be a positive integer")
+
+            # Enable trading first for all trade operations.
+            if check_approval:
+                self.enable_trading()
+
+            topic_detail = self.get_market(market_id)
+            market_data = self._validate_market_response(topic_detail, "get market for merge")
+
+            if int(market_data.chain_id) != self.chain_id:
+                raise OpenApiError('Cannot merge on different chain')
+
+            status = market_data.status
+            if not (status == TopicStatus.ACTIVATED.value or status == TopicStatus.RESOLVED.value or status == TopicStatus.RESOLVING.value):
+                raise OpenApiError('Cannot merge on non-activated/resolving/resolved market')
+            collateral = fast_to_checksum_address(market_data.quote_token)
+            condition_id = market_data.condition_id
+
+            tx_hash, safe_tx_hash, return_value = self.contract_caller.merge(collateral_token=collateral, condition_id=bytes.fromhex(condition_id),
+                                              amount=amount)
+            return self._format_transaction_result(tx_hash, safe_tx_hash, return_value)
+        except InvalidParamError as e:
+            logging.error(f"Validation error in merge: {e}")
+            raise
+        except OpenApiError as e:
+            logging.error(f"API error in merge: {e}")
+            raise
+        except Exception as e:
+            logging.error(f"Unexpected error in merge: {e}")
+            raise OpenApiError(f"Failed to merge tokens: {e}")
 
-    def redeem(self, market_id: int, check_approval: bool = True) -> Tuple[Any, Any, Any]:
+    def redeem(self, market_id: int, check_approval: bool = True) -> Tuple[Optional[str], Optional[str], Optional[str]]:
         """Redeem winning outcome tokens for collateral after market resolution.
 
         Args:
             market_id: The market ID to redeem tokens for (required)
             check_approval: Whether to check and enable trading approvals first
-        """
-        if not market_id or market_id <= 0:
-            raise InvalidParamError("market_id must be a positive integer")
 
-        # Enable trading first for all trade operations.
-        if check_approval:
-            self.enable_trading()
-
-        topic_detail = self.get_market(market_id)
-        market_data = self._validate_market_response(topic_detail, "get market for redeem")
-
-        if int(market_data.chain_id) != self.chain_id:
-            raise OpenApiError('Cannot redeem on different chain')
-
-        status = market_data.status
-        if not status == TopicStatus.RESOLVED.value:
-            raise OpenApiError('Cannot redeem on non-resolved market')
-        collateral = market_data.quote_token
-        condition_id = market_data.condition_id
-        logging.info(f'Redeem: collateral={collateral}, condition_id={condition_id}')
-        return self.contract_caller.redeem(collateral_token=collateral, condition_id=bytes.fromhex(condition_id))
+        Returns:
+            Tuple of (tx_hash, safe_tx_hash, return_value) as hex strings
+        """
+        try:
+            if not market_id or market_id <= 0:
+                raise InvalidParamError("market_id must be a positive integer")
+
+            # Enable trading first for all trade operations.
+            if check_approval:
+                self.enable_trading()
+
+            topic_detail = self.get_market(market_id)
+            market_data = self._validate_market_response(topic_detail, "get market for redeem")
+
+            if int(market_data.chain_id) != self.chain_id:
+                raise OpenApiError('Cannot redeem on different chain')
+
+            status = market_data.status
+            if not status == TopicStatus.RESOLVED.value:
+                raise OpenApiError('Cannot redeem on non-resolved market')
+            collateral = fast_to_checksum_address(market_data.quote_token)
+            condition_id = market_data.condition_id
+            logging.info(f'Redeem: collateral={collateral}, condition_id={condition_id}')
+            tx_hash, safe_tx_hash, return_value = self.contract_caller.redeem(collateral_token=collateral, condition_id=bytes.fromhex(condition_id))
+            return self._format_transaction_result(tx_hash, safe_tx_hash, return_value)
+        except InvalidParamError as e:
+            logging.error(f"Validation error in redeem: {e}")
+            raise
+        except OpenApiError as e:
+            logging.error(f"API error in redeem: {e}")
+            raise
+        except Exception as e:
+            logging.error(f"Unexpected error in redeem: {e}")
+            raise OpenApiError(f"Failed to redeem tokens: {e}")
 
     def get_quote_tokens(self, use_cache: bool = True) -> Any:
         """Get list of supported quote tokens
@@ -294,31 +389,40 @@ class Client:
 
     def get_markets(
         self,
-        topic_type: Optional[TopicType] = None,
+        topic_type: TopicType = TopicType.ALL,
         page: int = 1,
         limit: int = 20,
-        status: Optional[TopicStatusFilter] = None
+        status: Optional[TopicStatusFilter] = None,
+        sort_by: Optional['TopicSortType'] = None
     ) -> Any:
         """Get markets with pagination support.
 
         Args:
-            topic_type: Optional filter by topic type
+            topic_type: Filter by topic type. Defaults to TopicType.ALL (2).
+                - TopicType.ALL (2): All Markets (default)
+                - TopicType.CATEGORICAL (1): Categorical Market
+                - TopicType.BINARY (0): Binary Market
             page: Page number (>= 1)
             limit: Number of items per page (1-20)
             status: Optional filter by status
+            sort_by: Optional sort type (TopicSortType enum). Defaults to BY_TIME_DESC if not specified.
         """
         if page < 1:
             raise InvalidParamError("page must be >= 1")
         if not 1 <= limit <= 20:
             raise InvalidParamError("limit must be between 1 and 20")
 
+        # Default to BY_TIME_DESC (1) if sort_by is not specified
+        sort_value = sort_by.value if sort_by else TopicSortType.BY_TIME_DESC.value
+
         result = self.market_api.openapi_market_get(
             apikey=self.api_key,
             market_type=topic_type.value if topic_type else None,
             page=page,
             limit=limit,
             chain_id=str(self.chain_id),
-            status=status.value if status else None
+            status=status.value if status else None,
+            sort_by=sort_value
         )
         return result
 
@@ -438,19 +542,28 @@ class Client:
             raise OpenApiError(f"Failed to get latest price: {e}")
 
     def get_fee_rates(self, token_id):
-        """Get fee rates for a token"""
+        """Get fee rates for a token from FeeManager contract on-chain
+
+        Args:
+            token_id: Token ID to query fee rates for
+
+        Returns:
+            Dictionary containing:
+                - maker_max_fee_rate: Maker maximum fee rate as decimal (e.g., 0.02 = 2%)
+                - taker_max_fee_rate: Taker maximum fee rate as decimal (e.g., 0.02 = 2%)
+                - enabled: Whether fee is enabled
+        """
         try:
             if not token_id:
                 raise InvalidParamError(MISSING_TOKEN_ID_MSG)
 
-            result = self.market_api.openapi_token_fee_rates_get(apikey=self.api_key, token_id=token_id)
-            return result
+            return self.contract_caller.get_fee_rate_settings(token_id)
         except InvalidParamError as e:
             logging.error(f"Validation error: {e}")
             raise
         except Exception as e:
-            logging.error(f"API error: {e}")
-            raise OpenApiError(f"Failed to get fee rates: {e}")
+            logging.error(f"Chain query error: {e}")
+            raise OpenApiError(f"Failed to get fee rates from chain: {e}")
 
     def _place_order(self, data: OrderDataInput, exchange_addr='', chain_id=0, currency_addr='', currency_decimal=0, check_approval=False):
         if check_approval:
@@ -652,8 +765,8 @@ class Client:
 
         from opinion_api.models.openapi_cancel_order_request_open_api import OpenapiCancelOrderRequestOpenAPI
 
-        # Internally use trans_no for API compatibility
-        request_body = OpenapiCancelOrderRequestOpenAPI(trans_no=order_id)
+        # Use order_id for API request
+        request_body = OpenapiCancelOrderRequestOpenAPI(order_id=order_id)
         result = self.market_api.openapi_order_cancel_post(apikey=self.api_key, cancel_order_req=request_body)
         return result
 
@@ -768,6 +881,7 @@ class Client:
     def cancel_all_orders(self, market_id: Optional[int] = None, side: Optional[OrderSide] = None) -> dict:
         """
         Cancel all open orders, optionally filtered by market and/or side.
+        Uses pagination to fetch all orders (max 20 per page).
 
         Args:
             market_id: Optional filter - only cancel orders for this market
@@ -781,18 +895,40 @@ class Client:
                 'results': List[dict]
             }
         """
-        # Get all open orders
-        all_orders = self.get_my_orders(
-            market_id=market_id if market_id else 0,
-            status='open',
-            limit=100,  # Get up to 100 orders per page
-            page=1
-        )
+        # Collect all open orders using pagination
+        all_orders_list = []
+        page = 1
+        limit = 20  # Backend max page size
+        max_pages = 100  # Safety limit to prevent infinite loops
+
+        while page <= max_pages:
+            # Get orders for current page
+            page_orders = self.get_my_orders(
+                market_id=market_id if market_id else 0,
+                status='1',  # 1 = pending/open orders
+                limit=limit,
+                page=page
+            )
+
+            # Parse response to get order list
+            orders_list = self._parse_list_response(page_orders, f"get open orders page {page}")
+
+            if not orders_list or len(orders_list) == 0:
+                # No more orders on this page
+                break
+
+            all_orders_list.extend(orders_list)
 
-        # Parse response to get order list
-        orders_list = self._parse_list_response(all_orders, "get open orders for cancellation")
+            # If we got fewer orders than the limit, we've reached the last page
+            if len(orders_list) < limit:
+                break
 
-        if not orders_list or len(orders_list) == 0:
+            page += 1
+
+        if page > max_pages:
+            logging.warning(f"Reached maximum page limit ({max_pages}), there may be more orders")
+
+        if not all_orders_list or len(all_orders_list) == 0:
             logging.info("No open orders to cancel")
             return {
                 'total_orders': 0,
@@ -803,10 +939,10 @@ class Client:
 
         # Filter by side if specified
         if side:
-            orders_list = [order for order in orders_list if int(order.side) == int(side.value)]
+            all_orders_list = [order for order in all_orders_list if int(order.side) == int(side.value)]
 
-        # Extract order IDs (internally stored as trans_no)
-        order_ids = [order.trans_no for order in orders_list if hasattr(order, 'trans_no')]
+        # Extract order IDs from the response
+        order_ids = [order.order_id for order in all_orders_list if hasattr(order, 'order_id')]
 
         if not order_ids:
             logging.info("No orders match the filter criteria")
@@ -817,6 +953,8 @@ class Client:
                 'results': []
             }
 
+        logging.info(f"Found {len(order_ids)} orders to cancel")
+
         # Cancel all orders in batch
         results = self.cancel_orders_batch(order_ids)
 
@@ -841,7 +979,7 @@ class Client:
 
             result = self.market_api.openapi_order_get(
                 apikey=self.api_key,
-                topic_id=market_id if market_id > 0 else None,
+                market_id=market_id if market_id > 0 else None,
                 status=status if status else None,
                 limit=limit,
                 page=page,

opinion_clob_sdk/verify_checksum_addresses.py

@@ -0,0 +1,63 @@
+#!/usr/bin/env python3
+"""
+Verify that the FeeManager contract address is properly formatted
+and can be used with web3.py without checksum errors.
+"""
+
+import sys
+from web3 import Web3
+
+# Import the addresses
+from opinion_clob_sdk.config import (
+    BNB_CHAIN_FEE_MANAGER_ADDR,
+    BNB_CHAIN_CONDITIONAL_TOKENS_ADDR,
+    BNB_CHAIN_MULTISEND_ADDR,
+)
+
+def verify_address(name: str, address: str):
+    """Verify an address is in valid checksum format"""
+    try:
+        is_valid = Web3.is_checksum_address(address)
+        if is_valid:
+            print(f"✅ {name}: {address}")
+            print(f"   Valid checksum format")
+        else:
+            print(f"❌ {name}: {address}")
+            print(f"   Invalid checksum format")
+            return False
+    except Exception as e:
+        print(f"❌ {name}: {address}")
+        print(f"   Error: {e}")
+        return False
+    return True
+
+def main():
+    print("=" * 80)
+    print("Contract Address Checksum Verification")
+    print("=" * 80)
+    print()
+
+    addresses = {
+        "ConditionalTokens": BNB_CHAIN_CONDITIONAL_TOKENS_ADDR,
+        "Multisend": BNB_CHAIN_MULTISEND_ADDR,
+        "FeeManager": BNB_CHAIN_FEE_MANAGER_ADDR,
+    }
+
+    all_valid = True
+    for name, address in addresses.items():
+        if not verify_address(name, address):
+            all_valid = False
+        print()
+
+    print("=" * 80)
+    if all_valid:
+        print("✅ All contract addresses are in valid checksum format!")
+        print("\nYou can now use these addresses with web3.py without errors.")
+        return 0
+    else:
+        print("❌ Some addresses are not in valid checksum format!")
+        print("\nPlease update config.py with proper checksum addresses.")
+        return 1
+
+if __name__ == "__main__":
+    sys.exit(main())

{opinion_clob_sdk-0.1.9.dist-info → opinion_clob_sdk-0.4.2.dist-info}/METADATA

@@ -1,12 +1,12 @@
 Metadata-Version: 2.4
 Name: opinion_clob_sdk
-Version: 0.1.9
-Summary: Opinion CLOB SDK - Python SDK for Opinion Prediction Market Central Limit Order Book API
+Version: 0.4.2
+Summary: Opinion CLOB SDK (Tech Preview) - 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
+Keywords: PredictionMarket,CLOB,Trading,Blockchain,BNBChain,BSC,Opinion
+Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: License :: OSI Approved :: MIT License
@@ -26,7 +26,7 @@ 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.0
+Requires-Dist: opinion_api>=0.2.0
 Requires-Dist: pytest>=7.0.0
 Dynamic: author
 Dynamic: author-email
@@ -40,7 +40,9 @@ Dynamic: requires-python
 Dynamic: summary
 
 
-# Opinion CLOB SDK
+# Opinion CLOB SDK (Tech Preview)
+
+**Technology Preview Release - BNB Chain Support**
 
 Python SDK for interacting with Opinion prediction markets via the CLOB (Central Limit Order Book) API.
 
@@ -50,7 +52,7 @@ Python SDK for interacting with Opinion prediction markets via the CLOB (Central
 - Order management (place, cancel, query orders)
 - Position and balance tracking
 - Smart contract interactions (split, merge, redeem)
-- Support for Base mainnet (chain ID 8453)
+- Support for BNB Chain mainnet (chain ID 56)
 
 ## Installation
 
@@ -64,10 +66,10 @@ pip install opinion_clob_sdk
 from opinion_clob_sdk import Client
 
 client = Client(
-    host='https://api.opinion.trade',
+    host='https://proxy.opinion.trade:8443',
     apikey='your_api_key',
-    chain_id=8453,  # Base mainnet
-    rpc_url='your_rpc_url',
+    chain_id=56,  # BNB Chain mainnet
+    rpc_url='https://bsc-dataseed.binance.org',
     private_key='your_private_key',
     multi_sig_addr='your_multi_sig_address'
 )