opinion-clob-sdk 0.1.1__py3-none-any.whl → 0.1.2__py3-none-any.whl

opinion_clob_sdk/opinion_clob_sdk/sdk.py

@@ -0,0 +1,946 @@
+from typing import List, Optional, Dict, Any, Tuple
+import logging
+import math
+from time import time
+from decimal import Decimal
+
+from eth_typing import ChecksumAddress, HexStr
+from opinion_api.api.prediction_market_api import PredictionMarketApi
+from opinion_api.api.user_api import UserApi
+from opinion_api.api_client import ApiClient
+from opinion_api.configuration import Configuration
+from opinion_clob_sdk.chain.safe.utils import fast_to_checksum_address
+from .chain.contract_caller import ContractCaller
+from .chain.py_order_utils.builders.order_builder import OrderBuilder
+from .chain.py_order_utils.model.order import OrderDataInput, OrderData, PlaceOrderDataInput
+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 .chain.py_order_utils.utils import calculate_order_amounts
+
+API_INTERNAL_ERROR_MSG = "Unable to process your request. Please contact technical support."
+MISSING_MARKET_ID_MSG = "market_id is required."
+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]
+
+class InvalidParamError(Exception):
+    pass
+
+class OpenApiError(Exception):
+    pass
+
+def safe_amount_to_wei(amount: float, decimals: int) -> int:
+    """
+    Safely convert human-readable amount to wei units without precision loss.
+
+    Args:
+        amount: Human-readable amount (e.g., 1.5 for 1.5 tokens)
+        decimals: Token decimals (e.g., 6 for USDC, 18 for ETH)
+
+    Returns:
+        Integer amount in wei units
+
+    Raises:
+        InvalidParamError: If amount or decimals are invalid
+    """
+    if amount <= 0:
+        raise InvalidParamError(f"Amount must be positive, got: {amount}")
+
+    if decimals < 0 or decimals > MAX_DECIMALS:
+        raise InvalidParamError(f"Decimals must be between 0 and {MAX_DECIMALS}, got: {decimals}")
+
+    # Use Decimal for exact calculation
+    amount_decimal = Decimal(str(amount))
+    multiplier = Decimal(10) ** decimals
+
+    result_decimal = amount_decimal * multiplier
+
+    # Convert to int
+    result = int(result_decimal)
+
+    # Validate result fits in uint256
+    if result >= 2**256:
+        raise InvalidParamError(f"Amount too large for uint256: {result}")
+
+    if result <= 0:
+        raise InvalidParamError(f"Calculated amount is zero or negative: {result}")
+
+    return result
+
+class Client:
+    def __init__(
+        self,
+        host: str = '',
+        apikey: str = '',
+        chain_id: Optional[int] = None,
+        rpc_url: str = '',
+        private_key: HexStr = HexStr(''),
+        multi_sig_addr: str = '',
+        conditional_tokens_addr: ChecksumAddress = ChecksumAddress(''),
+        multisend_addr: ChecksumAddress = ChecksumAddress(''),
+        enable_trading_check_interval: int = 3600,
+        quote_tokens_cache_ttl: int = 3600,
+        market_cache_ttl: int = 300
+    ) -> None:
+        """
+        Initialize the Opinion CLOB SDK client.
+
+        Args:
+            host: API host URL
+            apikey: API authentication key
+            chain_id: Blockchain chain ID (8453 for Base 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
+            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.
+            quote_tokens_cache_ttl: Time interval (in seconds) to cache quote tokens data.
+                Default is 3600 (1 hour). Set to 0 to disable caching.
+            market_cache_ttl: Time interval (in seconds) to cache market data.
+                Default is 300 (5 minutes). Set to 0 to disable caching.
+        """
+        self.conf = Configuration(host=host)
+        self.conf.api_key['ApiKeyAuth'] = apikey
+        multi_sig_addr = fast_to_checksum_address(multi_sig_addr)
+        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,
+                                              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
+        self.market_cache_ttl = market_cache_ttl
+        self._quote_tokens_cache: Optional[Any] = None
+        self._quote_tokens_cache_time: float = 0
+        self._market_cache: Dict[int, Tuple[Any, float]] = {}  # market_id -> (data, timestamp)
+
+    def _validate_market_response(self, response: Any, operation_name: str = "operation") -> Any:
+        """Validate and extract market data from API response"""
+        if hasattr(response, 'errno') and response.errno != 0:
+            raise OpenApiError(f"Failed to {operation_name}: {response}")
+
+        if not hasattr(response, 'result') or not hasattr(response.result, 'data'):
+            raise OpenApiError(f"Invalid response format for {operation_name}")
+
+        return response.result.data
+
+    def _parse_list_response(self, response: Any, operation_name: str = "operation") -> List[Any]:
+        """Parse response that contains a list"""
+        if hasattr(response, 'errno') and response.errno != 0:
+            raise OpenApiError(f"Failed to {operation_name}: {response}")
+
+        if not hasattr(response, 'result') or not hasattr(response.result, 'list'):
+            raise OpenApiError(f"Invalid list response format for {operation_name}")
+
+        return response.result.list
+
+    def enable_trading(self) -> Tuple[Any, Any, Any]:
+        quote_token_list_response = self.get_quote_tokens()
+        quote_token_list = self._parse_list_response(quote_token_list_response, "get quote tokens")
+
+        supported_quote_tokens: dict = {}
+
+        # for each quote token, check if the chain_id is the same as the chain_id in the contract_caller
+        for quote_token in quote_token_list:
+            quote_token_address = fast_to_checksum_address(quote_token.currency_address)
+            ctf_exchange_address = fast_to_checksum_address(quote_token.ctfexchange_address)
+            supported_quote_tokens[quote_token_address] = ctf_exchange_address
+
+        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)
+
+    def split(self, market_id: int, amount: int, check_approval: bool = True) -> Tuple[Any, Any, Any]:
+        """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
+        """
+        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 split")
+
+        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.currency_address)
+        condition_id = market_data.condition_id
+
+        return self.contract_caller.split(collateral_token=collateral, condition_id=bytes.fromhex(condition_id), amount=amount)
+
+    def merge(self, market_id: int, amount: int, check_approval: bool = True) -> Tuple[Any, Any, Any]:
+        """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.currency_address)
+        condition_id = market_data.condition_id
+
+        return self.contract_caller.merge(collateral_token=collateral, condition_id=bytes.fromhex(condition_id),
+                                          amount=amount)
+
+    def redeem(self, market_id: int, check_approval: bool = True) -> Tuple[Any, Any, Any]:
+        """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.currency_address
+        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))
+
+    def get_quote_tokens(self, use_cache: bool = True) -> Any:
+        """Get list of supported quote tokens
+
+        Args:
+            use_cache: Whether to use cached data if available (default True).
+                Set to False to force a fresh API call.
+        """
+        current_time = time()
+
+        # Check cache if enabled
+        if use_cache and self.quote_tokens_cache_ttl > 0:
+            if self._quote_tokens_cache is not None:
+                cache_age = current_time - self._quote_tokens_cache_time
+                if cache_age < self.quote_tokens_cache_ttl:
+                    logging.debug(f"Using cached quote tokens (age: {cache_age:.1f}s)")
+                    return self._quote_tokens_cache
+
+        # Fetch fresh data
+        logging.debug("Fetching fresh quote tokens from API")
+        result = self.market_api.openapi_quote_token_get(apikey=self.api_key, chain_id=str(self.chain_id))
+
+        # Update cache
+        if self.quote_tokens_cache_ttl > 0:
+            self._quote_tokens_cache = result
+            self._quote_tokens_cache_time = current_time
+
+        return result
+
+    # Deprecated: use get_quote_tokens() instead
+    def get_currencies(self) -> Any:
+        """Deprecated: Use get_quote_tokens() instead"""
+        return self.get_quote_tokens()
+
+    def get_markets(
+        self,
+        topic_type: Optional[TopicType] = None,
+        page: int = 1,
+        limit: int = 20,
+        status: Optional[TopicStatusFilter] = None
+    ) -> Any:
+        """Get markets with pagination support.
+
+        Args:
+            topic_type: Optional filter by topic type
+            page: Page number (>= 1)
+            limit: Number of items per page (1-20)
+            status: Optional filter by status
+        """
+        if page < 1:
+            raise InvalidParamError("page must be >= 1")
+        if not 1 <= limit <= 20:
+            raise InvalidParamError("limit must be between 1 and 20")
+
+        result = self.market_api.openapi_market_get(
+            apikey=self.api_key,
+            topic_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
+        )
+        return result
+
+    def get_market(self, market_id, use_cache: bool = True):
+        """Get detailed information about a specific market
+
+        Args:
+            market_id: The market ID to query
+            use_cache: Whether to use cached data if available (default True).
+                Set to False to force a fresh API call.
+        """
+        try:
+            if not market_id:
+                raise InvalidParamError(MISSING_MARKET_ID_MSG)
+
+            current_time = time()
+
+            # Check cache if enabled
+            if use_cache and self.market_cache_ttl > 0:
+                if market_id in self._market_cache:
+                    cached_data, cache_time = self._market_cache[market_id]
+                    cache_age = current_time - cache_time
+                    if cache_age < self.market_cache_ttl:
+                        logging.debug(f"Using cached market {market_id} (age: {cache_age:.1f}s)")
+                        return cached_data
+
+            # Fetch fresh data
+            logging.debug(f"Fetching fresh market {market_id} from API")
+            result = self.market_api.openapi_market_market_id_get(apikey=self.api_key, market_id=market_id)
+
+            # Update cache
+            if self.market_cache_ttl > 0:
+                self._market_cache[market_id] = (result, current_time)
+
+            return result
+        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 market: {e}")
+
+    def get_categorical_market(self, market_id):
+        """Get detailed information about a categorical market"""
+        try:
+            if not market_id:
+                raise InvalidParamError(MISSING_MARKET_ID_MSG)
+
+            result = self.market_api.openapi_market_categorical_market_id_get(apikey=self.api_key, market_id=market_id)
+            return result
+        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 categorical market: {e}")
+
+    def get_price_history(self, token_id, interval="1hour", start_time=int(time()), bars=60):
+        """Get price history/candlestick data for a token"""
+        try:
+            if not token_id:
+                raise InvalidParamError(MISSING_TOKEN_ID_MSG)
+
+            if not interval:
+                raise InvalidParamError('interval is required')
+
+            result = self.market_api.openapi_token_price_history_get(
+                apikey=self.api_key,
+                token_id=token_id,
+                interval=interval,
+                start_time=start_time,
+                bars=bars
+            )
+            return result
+        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 price history: {e}")
+
+    def get_orderbook(self, token_id):
+        """Get orderbook for a specific token"""
+        try:
+            if not token_id:
+                raise InvalidParamError(MISSING_TOKEN_ID_MSG)
+
+            result = self.market_api.openapi_token_orderbook_get(apikey=self.api_key, token_id=token_id)
+            return result
+        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 orderbook: {e}")
+
+    def get_latest_price(self, token_id):
+        """Get latest price for a token"""
+        try:
+            if not token_id:
+                raise InvalidParamError(MISSING_TOKEN_ID_MSG)
+
+            result = self.market_api.openapi_token_latest_price_get(apikey=self.api_key, token_id=token_id)
+            return result
+        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 latest price: {e}")
+
+    def get_fee_rates(self, token_id):
+        """Get fee rates for a token"""
+        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
+        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}")
+
+    def _place_order(self, data: OrderDataInput, exchange_addr='', chain_id=0, currency_addr='', currency_decimal=0, check_approval=False):
+        if check_approval:
+            self.enable_trading()
+        try:
+            if not exchange_addr:
+                raise InvalidParamError('exchange_addr is required')
+
+            # Validate currency_decimal to prevent overflow
+            if currency_decimal < 0:
+                raise InvalidParamError(f'currency_decimal must be non-negative, got: {currency_decimal}')
+            if currency_decimal > MAX_DECIMALS:
+                raise InvalidParamError(f'currency_decimal too large (max {MAX_DECIMALS}): {currency_decimal}')
+
+            chain_id = self.chain_id
+
+            builder = OrderBuilder(exchange_addr, chain_id, self.contract_caller.signer)
+            takerAmount = 0
+
+            if data.orderType == MARKET_ORDER:
+                takerAmount = 0
+                data.price = "0"
+                # Use safe conversion to avoid precision loss
+                recalculated_maker_amount = safe_amount_to_wei(data.makerAmount, currency_decimal)
+            if data.orderType == LIMIT_ORDER:
+                # Use safe conversion to avoid precision loss
+                maker_amount_wei = safe_amount_to_wei(data.makerAmount, currency_decimal)
+                recalculated_maker_amount, takerAmount = calculate_order_amounts(
+                    price=float(data.price),
+                    maker_amount=maker_amount_wei,
+                    side=data.side,
+                    decimals=currency_decimal
+                )
+
+            order_data = OrderData(
+                maker=self.contract_caller.multi_sig_addr,
+                taker=ZERO_ADDRESS,
+                tokenId=data.tokenId,
+                makerAmount=recalculated_maker_amount,
+                takerAmount=takerAmount,
+                feeRateBps='0',
+                side=data.side,
+                signatureType=POLY_GNOSIS_SAFE,
+                signer=self.contract_caller.signer.address()
+            )
+            signerOrder = builder.build_signed_order(order_data)
+
+            order_dict = signerOrder.order.dict()
+
+            # Create V2AddOrderReq object for opinion_api
+            from opinion_api.models.v2_add_order_req import V2AddOrderReq
+
+            v2_add_order_req = V2AddOrderReq(
+                salt=str(order_dict['salt']),
+                topic_id=data.marketId,
+                maker=order_dict['maker'],
+                signer=order_dict['signer'],
+                taker=order_dict['taker'],
+                token_id=str(order_dict['tokenId']),
+                maker_amount=str(order_dict['makerAmount']),
+                taker_amount=str(order_dict['takerAmount']),
+                expiration=str(order_dict['expiration']),
+                nonce=str(order_dict['nonce']),
+                fee_rate_bps=str(order_dict['feeRateBps']),
+                side=str(order_dict['side']),
+                signature_type=str(order_dict['signatureType']),
+                signature=signerOrder.signature,
+                sign=signerOrder.signature,
+                contract_address="",
+                currency_address=currency_addr,
+                price=data.price,
+                trading_method=int(data.orderType),
+                timestamp=int(time()),
+                safe_rate='0',
+                order_exp_time='0'
+            )
+
+            result = self.market_api.openapi_order_post(apikey=self.api_key, v2_add_order_req=v2_add_order_req)
+            return result
+        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 place order: {e}")
+
+    def place_order(self, data: PlaceOrderDataInput, check_approval=False):
+        """Place an order on the market"""
+        quote_token_list_response = self.get_quote_tokens()
+        quote_token_list = self._parse_list_response(quote_token_list_response, "get quote tokens")
+
+        market_response = self.get_market(data.marketId)
+        market = self._validate_market_response(market_response, "get market for place order")
+
+        if int(market.chain_id) != self.chain_id:
+            raise OpenApiError('Cannot place order on different chain')
+
+        quote_token_addr = market.currency_address
+
+        # find quote token from quote_token_list by currency_address
+        quote_token = next((item for item in quote_token_list if str.lower(item.currency_address) == str.lower(quote_token_addr)), None)
+        if not quote_token:
+            raise OpenApiError('Quote token not found for this market')
+
+        exchange_addr = quote_token.ctfexchange_address
+        chain_id = quote_token.chain_id
+
+        makerAmount = 0
+        minimal_maker_amount = 1
+
+        # reject if market buy and makerAmountInBaseToken is provided
+        if(data.side == OrderSide.BUY and data.orderType == MARKET_ORDER and data.makerAmountInBaseToken):
+            raise InvalidParamError('makerAmountInBaseToken is not allowed for market buy')
+
+        # reject if market sell and makerAmountInQuoteToken is provided
+        if(data.side == OrderSide.SELL and data.orderType == MARKET_ORDER and data.makerAmountInQuoteToken):
+            raise InvalidParamError('makerAmountInQuoteToken is not allowed for market sell')
+
+        # Validate price for limit orders (prevent division by zero)
+        if data.orderType == LIMIT_ORDER:
+            try:
+                price_decimal = Decimal(str(data.price))
+                if price_decimal <= 0:
+                    raise InvalidParamError(f'Price must be positive for limit orders, got: {data.price}')
+            except (ValueError, TypeError, InvalidParamError):
+                raise
+            except Exception as e:
+                raise InvalidParamError(f'Invalid price format: {data.price}') from e
+
+        # need amount to be in quote token
+        if(data.side == OrderSide.BUY):
+            # e.g. yes/no
+            if(data.makerAmountInBaseToken):
+                # Use Decimal for precise calculation to avoid floating point errors
+                base_amount = Decimal(str(data.makerAmountInBaseToken))
+                price_decimal = Decimal(str(data.price))
+                makerAmount = float(base_amount * price_decimal)
+                # makerAmountInBaseToken should be at least 1 otherwise throw error
+                if(float(data.makerAmountInBaseToken) < minimal_maker_amount):
+                    raise InvalidParamError("makerAmountInBaseToken must be at least 1")
+            # e.g. usdc
+            elif(data.makerAmountInQuoteToken):
+                makerAmount = float(data.makerAmountInQuoteToken)
+                # makerAmountInQuoteToken should be at least 1 otherwise throw error
+                if(float(data.makerAmountInQuoteToken) < minimal_maker_amount):
+                    raise InvalidParamError("makerAmountInQuoteToken must be at least 1")
+            else:
+                raise InvalidParamError("Either makerAmountInBaseToken or makerAmountInQuoteToken must be provided for BUY orders")
+
+        elif(data.side == OrderSide.SELL):
+            # e.g. yes/no
+            if(data.makerAmountInBaseToken):
+                makerAmount = float(data.makerAmountInBaseToken)
+                # makerAmountInBaseToken should be at least 1 otherwise throw error
+                if(float(data.makerAmountInBaseToken) < minimal_maker_amount):
+                    raise InvalidParamError("makerAmountInBaseToken must be at least 1")
+            # e.g. usdc
+            elif(data.makerAmountInQuoteToken):
+                # Use Decimal for precise division to avoid floating point errors
+                quote_amount = Decimal(str(data.makerAmountInQuoteToken))
+                price_decimal = Decimal(str(data.price))
+                if price_decimal == 0:
+                    raise InvalidParamError("Price cannot be zero for SELL orders with makerAmountInQuoteToken")
+                makerAmount = float(quote_amount / price_decimal)
+                # makerAmountInQuoteToken should be at least 1 otherwise throw error
+                if(float(data.makerAmountInQuoteToken) < minimal_maker_amount):
+                    raise InvalidParamError("makerAmountInQuoteToken must be at least 1")
+            else:
+                raise InvalidParamError("Either makerAmountInBaseToken or makerAmountInQuoteToken must be provided for SELL orders")
+
+        # Final validation: ensure makerAmount was properly calculated
+        if makerAmount <= 0:
+            raise InvalidParamError(f"Calculated makerAmount must be positive, got: {makerAmount}")
+
+
+        input = OrderDataInput(
+            marketId=data.marketId,
+            tokenId=data.tokenId,
+            makerAmount=makerAmount,
+            price=data.price,
+            orderType=data.orderType,
+            side=data.side
+        )
+
+        return self._place_order(input, exchange_addr, chain_id, quote_token_addr, int(quote_token.decimal), check_approval)
+
+    def cancel_order(self, order_id):
+        """
+        Cancel an existing order.
+
+        Args:
+            order_id: Order ID to cancel (str)
+
+        Returns:
+            API response for order cancellation
+        """
+        if not order_id or not isinstance(order_id, str):
+            raise InvalidParamError('order_id must be a non-empty string')
+
+        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)
+        result = self.market_api.openapi_order_cancel_post(apikey=self.api_key, openapi_cancel_order_request_open_api=request_body)
+        return result
+
+    def place_orders_batch(self, orders: List[PlaceOrderDataInput], check_approval: bool = False) -> List[Any]:
+        """
+        Place multiple orders in batch to reduce API calls.
+
+        Args:
+            orders: List of PlaceOrderDataInput objects
+            check_approval: Whether to check and enable trading approvals first (done once for all orders)
+
+        Returns:
+            List of order placement results
+
+        Raises:
+            InvalidParamError: If orders list is empty or invalid
+        """
+        if not orders or not isinstance(orders, list):
+            raise InvalidParamError('orders must be a non-empty list')
+
+        if len(orders) == 0:
+            raise InvalidParamError('orders list cannot be empty')
+
+        # Enable trading once for all orders if needed
+        if check_approval:
+            self.enable_trading()
+
+        results = []
+        errors = []
+
+        for i, order in enumerate(orders):
+            try:
+                # Place each order without checking approval again
+                result = self.place_order(order, check_approval=False)
+                results.append({
+                    'index': i,
+                    'success': True,
+                    'result': result,
+                    'order': order
+                })
+            except Exception as e:
+                logging.error(f"Failed to place order at index {i}: {e}")
+                errors.append({
+                    'index': i,
+                    'success': False,
+                    'error': str(e),
+                    'order': order
+                })
+                results.append({
+                    'index': i,
+                    'success': False,
+                    'error': str(e),
+                    'order': order
+                })
+
+        if errors:
+            logging.warning(f"Batch order placement completed with {len(errors)} errors out of {len(orders)} orders")
+
+        return results
+
+    def cancel_orders_batch(self, order_ids: List[str]) -> List[Any]:
+        """
+        Cancel multiple orders in batch.
+
+        Args:
+            order_ids: List of order IDs to cancel
+
+        Returns:
+            List of cancellation results
+
+        Raises:
+            InvalidParamError: If order_ids list is empty or invalid
+        """
+        if not order_ids or not isinstance(order_ids, list):
+            raise InvalidParamError('order_ids must be a non-empty list')
+
+        if len(order_ids) == 0:
+            raise InvalidParamError('order_ids list cannot be empty')
+
+        results = []
+        errors = []
+
+        for i, order_id in enumerate(order_ids):
+            try:
+                result = self.cancel_order(order_id)
+                results.append({
+                    'index': i,
+                    'success': True,
+                    'result': result,
+                    'order_id': order_id
+                })
+            except Exception as e:
+                logging.error(f"Failed to cancel order {order_id}: {e}")
+                errors.append({
+                    'index': i,
+                    'success': False,
+                    'error': str(e),
+                    'order_id': order_id
+                })
+                results.append({
+                    'index': i,
+                    'success': False,
+                    'error': str(e),
+                    'order_id': order_id
+                })
+
+        if errors:
+            logging.warning(f"Batch order cancellation completed with {len(errors)} errors out of {len(order_ids)} orders")
+
+        return results
+
+    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.
+
+        Args:
+            market_id: Optional filter - only cancel orders for this market
+            side: Optional filter - only cancel BUY or SELL orders
+
+        Returns:
+            Dictionary with cancellation summary: {
+                'total_orders': int,
+                'cancelled': int,
+                'failed': int,
+                '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
+        )
+
+        # Parse response to get order list
+        orders_list = self._parse_list_response(all_orders, "get open orders for cancellation")
+
+        if not orders_list or len(orders_list) == 0:
+            logging.info("No open orders to cancel")
+            return {
+                'total_orders': 0,
+                'cancelled': 0,
+                'failed': 0,
+                'results': []
+            }
+
+        # Filter by side if specified
+        if side:
+            orders_list = [order for order in 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')]
+
+        if not order_ids:
+            logging.info("No orders match the filter criteria")
+            return {
+                'total_orders': 0,
+                'cancelled': 0,
+                'failed': 0,
+                'results': []
+            }
+
+        # Cancel all orders in batch
+        results = self.cancel_orders_batch(order_ids)
+
+        # Count successes and failures
+        cancelled = sum(1 for r in results if r.get('success'))
+        failed = sum(1 for r in results if not r.get('success'))
+
+        logging.info(f"Cancelled {cancelled} orders, {failed} failed out of {len(order_ids)} total")
+
+        return {
+            'total_orders': len(order_ids),
+            'cancelled': cancelled,
+            'failed': failed,
+            'results': results
+        }
+
+    def get_my_orders(self, market_id=0, status="", limit=10, page=1):
+        """Get user's orders with optional filters"""
+        try:
+            if not isinstance(market_id, int):
+                raise InvalidParamError('market_id must be an integer')
+
+            result = self.market_api.openapi_order_get(
+                apikey=self.api_key,
+                topic_id=market_id if market_id > 0 else None,
+                status=status if status else None,
+                limit=limit,
+                page=page,
+                chain_id=str(self.chain_id)
+            )
+            return result
+        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 orders: {e}")
+
+    def get_order_by_id(self, order_id):
+        """Get detailed information about a specific order"""
+        try:
+            if not order_id or not isinstance(order_id, str):
+                raise InvalidParamError('order_id must be a non-empty string')
+
+            result = self.market_api.openapi_order_order_id_get(apikey=self.api_key, order_id=order_id)
+            return result
+        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 order by id: {e}")
+
+    def get_my_positions(
+        self,
+        market_id: int = 0,
+        page: int = 1,
+        limit: int = 10
+    ) -> Any:
+        """Get user's positions with optional filters
+
+        Args:
+            market_id: Optional filter by market ID (0 for all markets)
+            page: Page number (default 1)
+            limit: Number of items per page (default 10)
+        """
+        try:
+            if not isinstance(market_id, int):
+                raise InvalidParamError('market_id must be an integer')
+
+            if not isinstance(page, int):
+                raise InvalidParamError('page must be an integer')
+
+            if not isinstance(limit, int):
+                raise InvalidParamError('limit must be an integer')
+
+            result = self.market_api.openapi_positions_get(
+                apikey=self.api_key,
+                topic_id=market_id if market_id > 0 else None,
+                page=page,
+                limit=limit,
+                chain_id=str(self.chain_id)
+            )
+            return result
+        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 positions: {e}")
+
+    def get_my_balances(self, wallet_address=None):
+        """Get user's balances"""
+        try:
+            if not wallet_address:
+                wallet_address = self.contract_caller.signer.address()
+
+            result = self.market_api.openapi_user_balance_get(
+                apikey=self.api_key,
+                wallet_address=wallet_address,
+                chain_id=str(self.chain_id)
+            )
+            return result
+        except Exception as e:
+            logging.error(f"API error: {e}")
+            raise OpenApiError(f"Failed to get balances: {e}")
+
+    def get_my_trades(self, market_id=0, limit=10):
+        """Get user's trade history"""
+        try:
+            if not isinstance(market_id, int):
+                raise InvalidParamError('market_id must be an integer')
+
+            result = self.market_api.openapi_trade_get(
+                apikey=self.api_key,
+                topic_id=market_id if market_id > 0 else None,
+                limit=limit,
+                chain_id=str(self.chain_id)
+            )
+            return result
+        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 trades: {e}")
+
+    def get_user_auth(self):
+        """Get authenticated user information"""
+        try:
+            result = self.user_api.openapi_user_auth_get(apikey=self.api_key)
+            return result
+        except Exception as e:
+            logging.error(f"API error: {e}")
+            raise OpenApiError(f"Failed to get user auth: {e}")