Opinion

https://docs.opinion.trade
Admin
Opinion is a high-performance prediction exchange that democratizes global economic trading by...
Tokens:105,029
Snippets:636
Trust Score:5.8
Update:8 months ago
Show doc for...
Tokens:
Raw
### Install and Run Python Script

Source: https://docs.opinion.trade/developer-guide/opinion-clob-sdk/getting-started/quick-start

Instructions for installing the required python-dotenv library and running a Python script. This is a common setup step for Python projects that use environment variables.

```bash
# Install python-dotenv if not already installed
pip install python-dotenv

# Run the script
python my_first_app.py
```

--------------------------------

### Configure Chain Selection for Production with Opinion Trade SDK

Source: https://docs.opinion.trade/developer-guide/opinion-clob-sdk/getting-started/quick-start

Set up the SDK for production deployment by specifying the correct host, chain ID, and RPC URL. This example demonstrates configuration for BNB Chain mainnet.

```python
client = Client(
    host='https://proxy.opinion.trade:8443',
    chain_id=56,  # BNB Chain mainnet
    rpc_url='https://bsc-dataseed.binance.org',  # BNB Chain RPC
    # ... other params ...
)
```

--------------------------------

### Verify Opinion CLOB SDK Installation (Command Line)

Source: https://docs.opinion.trade/developer-guide/opinion-clob-sdk/getting-started/installation

Command-line execution to verify the Opinion CLOB SDK installation by importing it and printing its version.

```bash
python -c "import opinion_clob_sdk; print('✓ Installed:', opinion_clob_sdk.__version__)"
```

--------------------------------

### Environment Setup for Opinion CLOB SDK

Source: https://docs.opinion.trade/developer-guide/opinion-clob-sdk/getting-started/quick-start

This snippet shows how to configure environment variables for the Opinion CLOB SDK. It requires a `.env` file containing API keys, RPC URLs, and other necessary credentials. These variables are essential for initializing the SDK client.

```bash
# .env file
API_KEY=your_api_key_here
RPC_URL=https://bsc-dataseed.binance.org
PRIVATE_KEY=0x1234567890abcdef...
MULTI_SIG_ADDRESS=0xYourWalletAddress...
HOS T=https://proxy.opinion.trade:8443
CHAIN_ID=56
CONDITIONAL_TOKEN_ADDR=0xAD1a38cEc043e70E83a3eC30443dB285ED10D774
MULTISEND_ADDR=0x998739BFdAAdde7C933B942a68053933098f9EDa
```

--------------------------------

### Install Opinion CLOB SDK from PyPI

Source: https://docs.opinion.trade/developer-guide/opinion-clob-sdk/getting-started/installation

Installs the latest stable version of the Opinion CLOB SDK and its dependencies using pip. This is the recommended installation method.

```bash
pip install opinion_clob_sdk
```

--------------------------------

### Place a Buy Order

Source: https://docs.opinion.trade/developer-guide/opinion-clob-sdk/getting-started/quick-start

Demonstrates how to place a limit buy order for a specific market and token. It requires enabling trading first and then constructing a PlaceOrderDataInput object with order details.

```python
from opinion_clob_sdk.chain.py_order_utils.model.order import PlaceOrderDataInput
from opinion_clob_sdk.chain.py_order_utils.model.sides import OrderSide
from opinion_clob_sdk.chain.py_order_utils.model.order_type import LIMIT_ORDER

# Enable trading (required once before placing orders)
client.enable_trading()

# Place a buy order of "No" token
order_data = PlaceOrderDataInput(
    marketId=813,
    tokenId='33095770954068818933468604332582424490740136703838404213332258128147961949614',
    side=OrderSide.BUY,
    orderType=LIMIT_ORDER,
    price='0.55',
    makerAmountInQuoteToken=10  # 10 USDT
)

result = client.place_order(order_data)
print(f"Order placed: {result}")
```

--------------------------------

### Verify Opinion CLOB SDK Installation (Python)

Source: https://docs.opinion.trade/developer-guide/opinion-clob-sdk/getting-started/installation

Python code snippet to verify the successful installation of the Opinion CLOB SDK by importing its modules and checking the version.

```python
import opinion_clob_sdk

# Check version
print(opinion_clob_sdk.__version__)  # Should print: 0.1.0 or higher

# Import main classes
from opinion_clob_sdk import Client
from opinion_clob_sdk.model import TopicType, TopicStatus

print("✓ Opinion CLOB SDK installed successfully!")
```

--------------------------------

### Python Get Markets Method Example

Source: https://docs.opinion.trade/developer-guide/opinion-clob-sdk/api-references/methods

Example of using the get_markets() method in Python to retrieve a paginated list of active binary prediction markets. It shows how to filter by topic type and status, and iterate through the results.

```python
from opinion_clob_sdk.model import TopicType, TopicStatusFilter

# Get all active binary markets
response = client.get_markets(
    topic_type=TopicType.BINARY,
    status=TopicStatusFilter.ACTIVATED,
    page=1,
    limit=10
)

if response.errno == 0:
    markets = response.result.list
    for market in markets:
        print(f"{market.market_id}: {market.market_title}")
```

--------------------------------

### Python Get Market Method Example

Source: https://docs.opinion.trade/developer-guide/opinion-clob-sdk/api-references/methods

Demonstrates how to fetch detailed information for a specific market using the get_market() method in Python. It includes an option to use cached data for efficiency.

```python
response = client.get_market(market_id=123, use_cache=True)

if response.errno == 0:
    market = response.result.data
    print(f"Title: {market.market_title}")
    print(f"Status: {market.status}")
    print(f"Condition ID: {market.condition_id}")
    print(f"Quote Token: {market.quote_token}")
```

--------------------------------

### Multi-Environment Configuration Setup (Python)

Source: https://docs.opinion.trade/developer-guide/opinion-clob-sdk/getting-started/configuration

Defines a dictionary to manage configurations for different environments (e.g., production, development) and a function to create an Opinion Trade client based on the selected environment. It uses environment variables prefixed with the environment name.

```python
import os
from opinion_clob_sdk import Client

ENVIRONMENTS = {
    'production': {
        'host': 'https://proxy.opinion.trade:8443',
        'chain_id': 56,  # BNB Chain Mainnet
        'rpc_url': 'https://bsc-dataseed.binance.org'
    }
}

def create_client(env='production'):
    config = ENVIRONMENTS[env]

    return Client(
        host=config['host'],
        apikey=os.getenv(f'{env.upper()}_API_KEY'),
        chain_id=config['chain_id'],
        rpc_url=config['rpc_url'],
        private_key=os.getenv(f'{env.upper()}_PRIVATE_KEY'),
        multi_sig_addr=os.getenv(f'{env.upper()}_MULTI_SIG_ADDRESS')
    )

# Usage
dev_client = create_client('development')
prod_client = create_client('production')
```

--------------------------------

### Create and Activate Conda Environment

Source: https://docs.opinion.trade/developer-guide/opinion-clob-sdk/getting-started/installation

Commands to create and activate a Conda environment with a specific Python version and install the Opinion CLOB SDK within it.

```bash
# Create environment
conda create -n opinion python=3.11

# Activate it
conda activate opinion

# Install SDK
pip install opinion_clob_sdk

# When done, deactivate
conda deactivate
```

--------------------------------

### Initialize Opinion Trade Client and Fetch Markets

Source: https://docs.opinion.trade/developer-guide/opinion-clob-sdk/getting-started/quick-start

Initializes the Opinion Trade client using environment variables for API keys and other credentials. It then fetches a list of active markets and displays their titles and IDs. Error handling for market fetching is included.

```python
from dotenv import load_dotenv
from opinion_clob_sdk.client import Client
from opinion_clob_sdk.types import TopicStatusFilter
import os

load_dotenv()

def main():
    client = Client(
        host='https://proxy.opinion.trade:8443',
        apikey=os.getenv('API_KEY'),
        chain_id=56,
        rpc_url=os.getenv('RPC_URL'),
        private_key=os.getenv('PRIVATE_KEY'),
        multi_sig_addr=os.getenv('MULTI_SIG_ADDRESS')
    )
    print("✓ Client initialized successfully!")

    markets_response = client.get_markets(
        status=TopicStatusFilter.ACTIVATED,
        limit=5
    )

    if markets_response.errno == 0:
        markets = markets_response.result.list
        print(f"\n✓ Found {len(markets)} active markets\n")

        for i, market in enumerate(markets, 1):
            print(f"{i}. {market.market_title}")
            print(f"   Market ID: {market.market_id}")
            print()

        if markets:
            first_market = markets[0]
            detail = client.get_categorical_market(market_id=first_market.market_id)

            if detail.errno == 0:
                m = detail.result.data
                print(f"✓ Details for '{m.market_title}':")
                print(f"  Status: {m.status}")
                print(f"  Question ID: {m.question_id}")
                print(f"  Quote Token: {m.quote_token}")
    else:
        print(f"Error fetching markets: {markets_response.errmsg}")

if __name__ == '__main__':
    main()
```

--------------------------------

### Install Opinion Clob SDK

Source: https://docs.opinion.trade/developer-guide/opinion-clob-sdk/support/faq

Provides instructions for installing the Opinion Clob SDK using pip and verifying the installation by checking the SDK version.

```bash
pip install opinion_clob_sdk

# Verify installation
python -c "import opinion_clob_sdk; print(opinion_clob_sdk.__version__)"
```

--------------------------------

### Implement Pagination for Large Datasets

Source: https://docs.opinion.trade/developer-guide/opinion-clob-sdk/getting-started/quick-start

Shows how to handle large datasets by implementing pagination. It repeatedly fetches data in chunks until all available records are retrieved, checking the number of items received in each request.

```python
page = 1
all_markets = []

while True:
    response = client.get_markets(page=page, limit=100)
    if response.errno != 0:
        break

    markets = response.result.list
    all_markets.extend(markets)

    # Check if more pages exist
    if len(markets) < 100:
        break

    page += 1

print(f"Total markets: {len(all_markets)}")
```

--------------------------------

### Get Orderbook Example (Python)

Source: https://docs.opinion.trade/developer-guide/opinion-clob-sdk/api-references/models

Illustrates how to retrieve and interpret order book data for a given market. It displays the best bid and ask prices and calculates the spread between them.

```python
book = client.get_orderbook("token_yes").result.data

# Best bid (highest buy price)
best_bid = book.bids[0] if book.bids else None
print(f"Best bid: ${best_bid['price']} x {best_bid['amount']}")

# Best ask (lowest sell price)
best_ask = book.asks[0] if book.asks else None
print(f"Best ask: ${best_ask['price']} x {best_ask['amount']}")

# Spread
if best_bid and best_ask:
    spread = float(best_ask['price']) - float(best_bid['price'])
    print(f"Spread: ${spread:.4f}")
```

--------------------------------

### Get Quote Tokens Example (Python)

Source: https://docs.opinion.trade/developer-guide/opinion-clob-sdk/api-references/models

Shows how to fetch a list of available quote tokens and print their symbols, addresses, decimals, and exchange addresses. This is useful for understanding the supported trading pairs.

```python
tokens = client.get_quote_tokens().result.list

for token in tokens:
    print(f"{token.symbol}: {token.quote_token_address}")
    print(f"  Decimals: {token.decimal}")
    print(f"  Exchange: {token.ctf_exchange_address}")
```

--------------------------------

### Create and Activate venv Environment

Source: https://docs.opinion.trade/developer-guide/opinion-clob-sdk/getting-started/installation

Commands to create and activate a Python virtual environment using the built-in 'venv' module. This isolates project dependencies.

```bash
# Create virtual environment
python3 -m venv venv

# Activate it
source venv/bin/activate  # macOS/Linux
# or
venv\Scripts\activate     # Windows

# Install SDK
pip install opinion_clob_sdk

# When done, deactivate
deactivate
```

--------------------------------

### Minimal Configuration for Read-Only Client (Python)

Source: https://docs.opinion.trade/developer-guide/opinion-clob-sdk/getting-started/configuration

Sets up a client for read-only operations, minimizing required parameters like `rpc_url` and `private_key`. This configuration allows access to GET methods but restricts trading and contract-related actions.

```python
# Minimal configuration for read-only access
client = Client(
    host='https://proxy.opinion.trade:8443',
    apikey=os.getenv('API_KEY'),
    chain_id=56,
    rpc_url='',           # Empty if not doing contract operations
    private_key='0x00',   # Dummy key if not placing orders
    multi_sig_addr='0x0000000000000000000000000000000000000000'
)

# Can use all GET methods
markets = client.get_markets()
market = client.get_market(123)
orderbook = client.get_orderbook('token_123')

# Cannot use trading or contract methods
# client.place_order(...)  # Would fail
# client.split(...)        # Would fail
```

--------------------------------

### Initialize Opinion CLOB SDK Client in Python

Source: https://docs.opinion.trade/developer-guide/opinion-clob-sdk/getting-started/quick-start

This Python code initializes the Opinion CLOB SDK client using environment variables loaded from a `.env` file. It requires the `dotenv` and `opinion_clob_sdk` libraries. The client is configured with host, API key, chain ID, RPC URL, private key, multi-sig address, and contract addresses.

```python
import os
from dotenv import load_dotenv
from opinion_clob_sdk import Client

# Load environment variables
load_dotenv()

# Initialize client
client = Client(
    host='https://proxy.opinion.trade:8443',
    apikey=os.getenv('API_KEY'),
    chain_id=56,  # BNB Chain mainnet
    rpc_url=os.getenv('RPC_URL'),
    private_key=os.getenv('PRIVATE_KEY'),
    multi_sig_addr=os.getenv('MULTI_SIG_ADDRESS'),
    conditional_tokens_addr=os.getenv('CONDITIONAL_TOKEN_ADDR'),
    multisend_addr=os.getenv('0x998739BFdAAdde7C933B942a68053933098f9EDa')
)

print("✓ Client initialized successfully!")
```

--------------------------------

### Get Market Data Example (Python)

Source: https://docs.opinion.trade/developer-guide/opinion-clob-sdk/api-references/models

Demonstrates how to retrieve and display information about a specific market using the Opinion Trade SDK. It fetches market data and prints its ID, title, status, type, and condition ID.

```python
market = client.get_market(123).result.data

print(f"ID: {market.topic_id}")
print(f"Title: {market.topic_title}")
print(f"Status: {market.status}")  # 2 = ACTIVATED
print(f"Type: {market.topic_type}")  # 0 = BINARY
print(f"Condition: {market.condition_id}")
```

--------------------------------

### Subscribe to Channel

Source: https://docs.opinion.trade/developer-guide/opinion-websocket/quickstart

Subscribe to specific market channels to receive real-time data. The required parameters depend on whether the market is binary or categorical.

```APIDOC
## Subscribe to Channel

### Description
Send a `SUBSCRIBE` message to a channel to receive real-time data. The specific market identifier (`marketId` or `rootMarketId`) depends on the channel type (binary or categorical).

### Method
WS SEND

### Endpoint
`wss://ws.opinion.trade`

### Request Body
- **action** (string) - Required - Must be set to `"SUBSCRIBE"`.
- **channel** (string) - Required - The identifier of the channel to subscribe to.
- **marketId** (integer) - Required for Binary markets - The ID of the binary market.
- **rootMarketId** (integer) - Required for Categorical markets - The ID of the root market for categorical markets.

### Request Example (Binary Market)
```json
{
  "action": "SUBSCRIBE",
  "channel": "{CHANNEL}",
  "marketId": {MARKET_ID}
}
```

### Request Example (Categorical Market)
```json
{
  "action": "SUBSCRIBE",
  "channel": "{CHANNEL}",
  "rootMarketId": {ROOT_MARKET_ID}
}
```
```

--------------------------------

### Perform Smart Contract Operations

Source: https://docs.opinion.trade/developer-guide/opinion-clob-sdk/getting-started/quick-start

Provides examples for interacting with smart contracts, including splitting quote tokens into outcome tokens, merging outcome tokens back into quote tokens, and redeeming winnings after a market resolves.

```python
# Split USDT into outcome tokens
tx_hash, receipt, event = client.split(
    market_id=813,
    amount=1000000000000000000  # 1 USDT (18 decimals for USDT)
)

# Merge outcome tokens back to USDT
tx_hash, receipt, event = client.merge(
    market_id=813,
    amount=1000000000000000000
)

# Redeem winnings after market resolves
tx_hash, receipt, event = client.redeem(market_id=813)
```

--------------------------------

### Check Python Version

Source: https://docs.opinion.trade/developer-guide/opinion-clob-sdk/getting-started/installation

Command to check the currently installed Python version. This is a prerequisite for installing the Opinion CLOB SDK.

```bash
python --version  # or python3 --version
```

--------------------------------

### Connect to Opinion Websocket API

Source: https://docs.opinion.trade/developer-guide/opinion-websocket/quickstart

Establishes a WebSocket Secure (wss) connection to the Opinion Websocket server. Requires an API key provided as a query parameter. This is the initial step to interact with the API.

```URL
wss://ws.opinion.trade?apikey={API_KEY}
```

--------------------------------

### Get Specific Market Details with Opinion CLOB SDK in Python

Source: https://docs.opinion.trade/developer-guide/opinion-clob-sdk/getting-started/quick-start

This Python code retrieves detailed information for a specific market using its ID. It calls the `get_market` method on the Opinion CLOB SDK client. The output includes the market's title, question ID, quote token, and chain ID, with error handling.

```python
# Get details for a specific market
market_id = markets[0].topic_id  # Use first market from above

market_detail = client.get_market(market_id)
if market_detail.errno == 0:
    market = market_detail.result.data
    print(f"\n✓ Market Details for #{market_id}:")
    print(f"  Title: {market.market_title}")
    print(f"  Question ID: {market.question_id}")
    print(f"  Quote Token: {market.quote_token}")
    print(f"  Chain ID: {market.chain_id}")
```

--------------------------------

### Python Get Categorical Market Method Example

Source: https://docs.opinion.trade/developer-guide/opinion-clob-sdk/api-references/methods

Example of retrieving detailed information for a categorical market using the get_categorical_market() method in Python. This method is specifically for markets with multiple outcomes.

```python
response = client.get_categorical_market(market_id=456)

if response.errno == 0:
    market = response.result.data
    print(f"Options: {market.options}")  # Multiple outcomes
```

--------------------------------

### Initialize Opinion CLOB SDK Client

Source: https://docs.opinion.trade/developer-guide/opinion-clob-sdk/getting-started/configuration

Demonstrates how to initialize the Opinion CLOB SDK's Client class with various configuration parameters. This includes network details, API authentication, and caching settings.

```python
from opinion_clob_sdk import Client

client = Client(
    host='https://proxy.opinion.trade:8443',
    apikey='your_api_key',
    chain_id=56,
    rpc_url='your_rpc_url',
    private_key='0x...',
    multi_sig_addr='0x...',
    conditional_tokens_addr='0xAD1a38cEc043e70E83a3eC30443dB285ED10D774',
    multisend_addr='0x998739BFdAAdde7C933B942a68053933098f9EDa',
    enable_trading_check_interval=3600,
    quote_tokens_cache_ttl=3600,
    market_cache_ttl=300
)
```

--------------------------------

### Correct Private Key Format for Python SDK

Source: https://docs.opinion.trade/developer-guide/opinion-clob-sdk/core-concepts/client

Illustrates common mistakes and the correct format for providing a private key when initializing the Opinion Trade SDK. It emphasizes the need for the '0x' prefix and valid hexadecimal characters.

```python
# Common mistakes
# private_key = 'ac0974bec...'  # Missing 0x prefix
# private_key = '0xGGGG...'     # Invalid hex

# Correct format
private_key = '0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80'
```

--------------------------------

### Upgrade Opinion CLOB SDK

Source: https://docs.opinion.trade/developer-guide/opinion-clob-sdk/getting-started/installation

Command to upgrade the Opinion CLOB SDK to the latest available version using pip.

```bash
pip install --upgrade opinion_clob_sdk
```

--------------------------------

### Unsubscribe from Channel

Source: https://docs.opinion.trade/developer-guide/opinion-websocket/quickstart

Unsubscribe from market channels to stop receiving real-time data. Use the same parameters as when subscribing.

```APIDOC
## Unsubscribe from Channel

### Description
Send an `UNSUBSCRIBE` message to stop receiving data from a specific channel. Use the same parameters as used for subscribing to the channel.

### Method
WS SEND

### Endpoint
`wss://ws.opinion.trade`

### Request Body
- **action** (string) - Required - Must be set to `"UNSUBSCRIBE"`.
- **channel** (string) - Required - The identifier of the channel to unsubscribe from.
- **marketId** (integer) - Required for Binary markets - The ID of the binary market.
- **rootMarketId** (integer) - Required for Categorical markets - The ID of the root market for categorical markets.

### Request Example (Binary Market)
```json
{
  "action": "UNSUBSCRIBE",
  "channel": "{CHANNEL}",
  "marketId": {MARKET_ID}
}
```

### Request Example (Categorical Market)
```json
{
  "action": "UNSUBSCRIBE",
  "channel": "{CHANNEL}",
  "rootMarketId": {ROOT_MARKET_ID}
}
```
```

--------------------------------

### Uninstall Opinion CLOB SDK

Source: https://docs.opinion.trade/developer-guide/opinion-clob-sdk/getting-started/installation

Command to remove the Opinion CLOB SDK and its associated files from the current Python environment using pip.

```bash
pip uninstall opinion_clob_sdk
```

--------------------------------

### Initialize Opinion CLOB SDK Client

Source: https://docs.opinion.trade/developer-guide/opinion-clob-sdk/support/faq

Demonstrates how to initialize the Opinion CLOB SDK client with essential API credentials. It highlights the use of `private_key` for signing and `multi_sig_addr` for asset management, emphasizing their distinct roles.

```python
client = Client(
    private_key='0x...',      # Hot wallet private key (signs orders)
    multi_sig_addr='0x...'    # Cold wallet address (holds assets)
)
```

--------------------------------

### Force Reinstall and Upgrade Opinion CLOB SDK

Source: https://docs.opinion.trade/developer-guide/opinion-clob-sdk/getting-started/installation

Command to forcefully reinstall the Opinion CLOB SDK and upgrade all its dependencies to their latest compatible versions.

```bash
pip install --upgrade --force-reinstall opinion_clob_sdk
```

--------------------------------

### Initialize Opinion Trade SDK Client (Python)

Source: https://docs.opinion.trade/developer-guide/opinion-clob-sdk/core-concepts/client

Demonstrates the minimal configuration required to initialize the Opinion Trade SDK Client. This includes setting the host, API key, chain ID, RPC URL, private key, and multi-signature address for secure and operational connectivity.

```python
from opinion_clob_sdk import Client

client = Client(
    host='https://proxy.opinion.trade:8443',
    apikey='your_api_key_here',
    chain_id=56,
    rpc_url='https://bsc-dataseed.binance.org',
    private_key='0x...',
    multi_sig_addr='0x...'
)
```

--------------------------------

### Maintain Connection with HEARTBEAT

Source: https://docs.opinion.trade/developer-guide/opinion-websocket/quickstart

Sends a HEARTBEAT message to the Opinion Websocket server to keep the connection active. This message should be sent periodically, for example, every 30 seconds, to prevent disconnections.

```JSON
{"action":"HEARTBEAT"}
```

--------------------------------

### Configure Caching Strategy with Python SDK

Source: https://docs.opinion.trade/developer-guide/opinion-clob-sdk/core-concepts/client

Shows how to configure caching strategies for the Opinion Trade SDK client to optimize performance for different use cases. It provides examples for aggressive caching (longer TTLs) for read-heavy workloads and minimal caching (shorter TTLs) for trading bots.

```python
# Aggressive caching for read-heavy workloads
client = Client(
    market_cache_ttl_seconds=300,      # 5 minutes
    quote_token_cache_ttl_seconds=3600 # 1 hour
)

# Minimal caching for trading bots
client = Client(
    market_cache_ttl_seconds=10,       # 10 seconds
    quote_token_cache_ttl_seconds=60   # 1 minute
)
```

--------------------------------

### Example: Place Buy Order (Python)

Source: https://docs.opinion.trade/developer-guide/opinion-clob-sdk/api-references/models

Demonstrates how to create a PlaceOrderDataInput object for a buy order, specifying the amount in quote tokens (USDT).

```python
order = PlaceOrderDataInput(
    marketId=123,
    tokenId="token_yes",
    side=OrderSide.BUY,
    orderType=LIMIT_ORDER,
    price="0.55",
    makerAmountInQuoteToken="100"  # Spend 100 USDT
)
```

--------------------------------

### Set System Environment Variables (Shell)

Source: https://docs.opinion.trade/developer-guide/opinion-clob-sdk/getting-started/configuration

Provides examples for setting environment variables directly in the shell for Linux/macOS, Windows Command Prompt, and Windows PowerShell. These variables can then be accessed by applications.

```bash
# Linux/macOS
export API_KEY="opn_prod_abc123xyz789"
export RPC_URL=___
export PRIVATE_KEY="0x..."
export MULTI_SIG_ADDRESS="0x..."

# Windows (Command Prompt)
set API_KEY=opn_prod_abc123xyz789
set RPC_URL=___

# Windows (PowerShell)
$env:API_KEY="opn_prod_abc123xyz789"
$env:RPC_URL=___
```

--------------------------------

### Load API Key from Environment Variable (Python)

Source: https://docs.opinion.trade/developer-guide/opinion-clob-sdk/core-concepts/client

Illustrates how to securely load the API key from environment variables using python-dotenv. This method avoids hardcoding sensitive credentials, enhancing security.

```python
import os
from dotenv import load_dotenv

load_dotenv()
apikey = os.getenv('API_KEY')  # Never hardcode!
```

--------------------------------

### Manage Positions and Trade History

Source: https://docs.opinion.trade/developer-guide/opinion-clob-sdk/getting-started/quick-start

Shows how to retrieve user-specific data such as account balances, open positions, and past trades. These functions are essential for tracking and analyzing trading activity.

```python
# Get balances
batches = client.get_my_balances()

# Get positions
positions = client.get_my_positions(limit=20)

# Get trade history
trades = client.get_my_trades(market_id=813)
```

--------------------------------

### Place a Limit Order with Opinion CLOB SDK (Python)

Source: https://docs.opinion.trade/developer-guide/opinion-clob-sdk/overview

Demonstrates how to place a limit order using the Opinion CLOB SDK. Requires initializing the Client with host, API key, and other parameters. The `PlaceOrderDataInput` model is used to define order details like market ID, token ID, side, type, price, and amount.

```python
from opinion_clob_sdk import Client
from opinion_clob_sdk.chain.py_order_utils.model.order import PlaceOrderDataInput
from opinion_clob_sdk.chain.py_order_utils.model.sides import OrderSide

client = Client(host='https://proxy.opinion.trade:8443', apikey='your_key', ...)

# Place a limit order
order = PlaceOrderDataInput(
    marketId=123,
    tokenId='token_yes',
    side=OrderSide.BUY,
    orderType=LIMIT_ORDER,
    price='0.55',
    makerAmountInQuoteToken=100
)
result = client.place_order(order)
```

--------------------------------

### Handle Specific SDK Exceptions with Try-Except

Source: https://docs.opinion.trade/developer-guide/opinion-clob-sdk/getting-started/quick-start

Demonstrates robust error handling using a try-except block to catch specific exceptions like `InvalidParamError` and `OpenApiError`, as well as general exceptions.

```python
from opinion_clob_sdk import InvalidParamError, OpenApiError

try:
    market = client.get_market(market_id=123)
except InvalidParamError as e:
    print(f"Invalid parameter: {e}")
except OpenApiError as e:
    print(f"API error: {e}")
except Exception as e:
    print(f"Unexpected error: {e}")
```

--------------------------------

### Example Error Handling in Python

Source: https://docs.opinion.trade/developer-guide/opinion-clob-sdk/api-references/methods

Demonstrates how to use a try-except block to catch and handle various custom exceptions raised by the SDK, including invalid parameters, API errors, and insufficient balances.

```python
try:
    result = client.place_order(order_data)
    if result.errno == 0:
        print("Success!")
    else:
        print(f"API Error: {result.errmsg}")

except InvalidParamError as e:
    print(f"Invalid parameter: {e}")
except OpenApiError as e:
    print(f"API error: {e}")
except BalanceNotEnough as e:
    print(f"Insufficient balance: {e}")
except Exception as e:
    print(f"Unexpected error: {e}")
```

--------------------------------

### Configure Opinion CLOB SDK RPC URL

Source: https://docs.opinion.trade/developer-guide/opinion-clob-sdk/getting-started/configuration

Sets the blockchain RPC endpoint URL for the Opinion CLOB SDK. This example shows public and private RPC options for BNB Chain Mainnet.

```python
# Public RPC (rate limited)
rpc_url='https://bsc-dataseed.binance.org'

# Private RPC (recommended for production)
rpc_url='https://bsc.nodereal.io'
```

--------------------------------

### Implement Connection Pooling with Python SDK

Source: https://docs.opinion.trade/developer-guide/opinion-clob-sdk/core-concepts/client

Explains the importance of connection pooling for performance when using the Opinion Trade SDK. It demonstrates the correct approach of creating a single client instance for multiple requests versus creating a new instance for each request, which is inefficient.

```python
# The SDK reuses HTTP connections automatically
# For long-running applications, create one client instance

# ✅ Good
client = Client(...)
for i in range(1000):
    markets = client.get_markets()

# ❌ Bad (creates 1000 connections)
# for i in range(1000):
#     client = Client(...)
#     markets = client.get_markets()
```

--------------------------------

### Enable Trading and Place Orders with Opinion CLOB SDK

Source: https://docs.opinion.trade/developer-guide/opinion-clob-sdk/support/faq

Shows two methods for enabling trading and placing orders with the Opinion CLOB SDK. Option 1 demonstrates manual `enable_trading()` for multiple orders, while Option 2 uses `check_approval=True` for automatic checks during single order placement.

```python
client.enable_trading()  # Call once

# Place many orders without checking again
client.place_order(order1)
client.place_order(order2)
client.place_order(order3)
```

```python
# Automatically checks and enables if needed
client.place_order(order, check_approval=True)
```

--------------------------------

### Example: Place Sell Order (Python)

Source: https://docs.opinion.trade/developer-guide/opinion-clob-sdk/api-references/models

Illustrates creating a PlaceOrderDataInput object for a sell order, specifying the amount in base tokens (YES tokens) for a market order.

```python
order = PlaceOrderDataInput(
    marketId=123,
    tokenId="token_yes",
    side=OrderSide.SELL,
    orderType=MARKET_ORDER,
    price="0",
    makerAmountInBaseToken="50"  # Sell 50 tokens
)
```
Tokens:
Raw