Python SDK#

pip install seesaw-sdk

cd packages/sdk-python
pip install -e ".[dev]"

# Trustless layer (depends on seesaw-sdk):
cd ../trustless-python
pip install -e .

from solders.pubkey import Pubkey
from seesaw import (
    PROGRAM_ID,
    OrderSide,
    OrderType,
    PlaceOrderAccounts,
    decode_market,
    derive_config_pda,
    derive_market_pda,
    pick_treasury_index,
    place_order,
)

# 1. Derive a market PDA
feed_id = bytes([0xAB] * 32)  # the market's 32-byte Pyth feed id
market_pda, bump = derive_market_pda(feed_id, 900, 1, creator_pubkey)

# 2. Decode a market account from raw bytes
market = decode_market(account_data)
print(f"Market state: {market.state}, outcome: {market.outcome}")
current_slot = 12_345  # Fetch the current slot from your Solana RPC client.
treasury_index = pick_treasury_index(wallet.pubkey(), current_slot, 8)

# 3. Build a PlaceOrder instruction (18 accounts, in on-chain order)
accounts = PlaceOrderAccounts(
    market=market_pda,
    orderbook=orderbook_pda,
    user_position=position_pda,
    user_token_account=user_ata,
    vault=vault_pda,
    user=wallet.pubkey(),
    config=config_pda,
    treasury_token_account=treasury_ata,  # config.treasury_recipients[protocol_treasury_index]
    token_program=TOKEN_PROGRAM_ID,
    system_program=SYSTEM_PROGRAM_ID,
    settlement_mint=settlement_mint,
    yes_escrow=yes_escrow_pda,
    no_escrow=no_escrow_pda,
    user_yes_ata=yes_ata,
    user_no_ata=no_ata,
    yes_mint=yes_mint_pda,
    no_mint=no_mint_pda,
    trader_ledger=trader_ledger_pda,
)
ix = place_order(
    accounts,
    side=OrderSide.BuyYes,
    price_bps=5000,                # 50%
    quantity=100_000_000,          # 100 USDT (6 decimals)
    order_type=OrderType.Limit,
    protocol_treasury_index=treasury_index,  # must match the treasury_token_account above
)
# Add ix to a transaction and send

from seesaw import CreateMarketAccounts, create_market_bundle

# Returns list[Instruction]: EnsureTraderLedgerSpace prelude(s) +
# EnsureDeepOrderbookSpace prelude(s) + CreateMarket. Submit in order.
# For large/max num_seats or orderbook tiers, split the preludes across
# transactions and submit CreateMarket (the last entry) in the final one.
instructions = create_market_bundle(
    accounts,                       # CreateMarketAccounts with all PDAs
    max_confidence_ratio_bps=500,   # 5%; 0 disables the confidence guard
    duration_seconds=900,           # 15-minute market
    bids_size=512,  # deep-orderbook tier: 64, 128, 256, 512, 1024, 2048, or 4096
    asks_size=512,  # must match bids_size
    num_seats=128,
    max_oracle_jump_bps=0,          # 0 = protocol default jump guard (5,000 bps)
    oracle_mode=1,                  # launch default: 1 = Pyth pull; 0 = legacy-compatible Pyth push
)

from solders.pubkey import Pubkey
from seesaw import OrderSide, OrderType, PlaceOrderAccounts, place_order
from seesaw_trustless import (
    SYSTEM_PROGRAM_ADDRESS,
    TOKEN_PROGRAM_ADDRESS,
    TrustlessResolver,
    TrustlessRpc,
    list_markets,
)

rpc = TrustlessRpc("https://your-node.example")  # any standard Solana RPC
resolver = TrustlessResolver(rpc)
user = Pubkey.from_string("YOUR_WALLET")

# Discover markets straight from chain state (no Seesaw API).
markets = list_markets(rpc)

# Resolve everything PlaceOrder needs — validated, slot-anchored. The
# treasury index/account pair is picked structurally from the on-chain
# config, and idempotent ATA-create instructions are returned for any of
# your token accounts that don't exist yet.
r = resolver.resolve_place_order(market_address=markets.value[0].address, user=user)
a = r.accounts

ix = place_order(
    PlaceOrderAccounts(
        market=a.market, orderbook=a.orderbook, user_position=a.user_position,
        user_token_account=a.user_token_account, vault=a.vault, user=user,
        config=a.config, treasury_token_account=a.treasury_token_account,
        token_program=TOKEN_PROGRAM_ADDRESS, system_program=SYSTEM_PROGRAM_ADDRESS,
        settlement_mint=a.settlement_mint, yes_escrow=a.yes_escrow,
        no_escrow=a.no_escrow, user_yes_ata=a.user_yes_ata,
        user_no_ata=a.user_no_ata, yes_mint=a.yes_mint, no_mint=a.no_mint,
        trader_ledger=a.trader_ledger,
    ),
    side=OrderSide.BuyYes,
    price_bps=6_500,
    quantity=1_000_000,
    order_type=OrderType.Limit,
    protocol_treasury_index=r.protocol_treasury_index,
)
# Assemble [*r.prepend_instructions, ix] into one transaction, simulate via
# rpc.simulate_transaction(base64_tx), then sign & send.

balances = resolver.get_trader_balances(market, user).value   # ledger buckets
orders = resolver.find_user_orders(market, user).value        # resting orders
position = resolver.get_position(market, user).value
status = resolver.get_referral_status(user, resolver.get_chain_unix_timestamp())

from seesaw.referral import ReferrerSource, ResolveInput, resolve_from_input
from seesaw.creator import parse_creator_markets

WALLET = "5Q544fKrFoe6tsEbD7S8EmxGTJYAKtTVhAW5Q5pge4j1"
REFERRER = "11111111111111111111111111111112"

# Resolve referrer from an indexer snapshot
resolution = resolve_from_input(
    WALLET,
    ResolveInput(
        indexer_snapshot={"referrer": REFERRER, "expires_at": 4_070_908_800_000},
        earnings_exists=True,
    ),
)
# resolution.source == ReferrerSource.INDEXER
# resolution.eligible_for_triple may be true only when the lock is current and the earnings PDA exists.
# Attach trailing accounts only after checking resolution.eligible_for_triple.

# Parse the creators endpoint response
markets = parse_creator_markets(raw_indexer_dict)
claimable = [m for m in markets if m.claimable_now]

cd packages/sdk-python
python -m venv .venv
.venv/bin/pip install -e ".[dev]"
.venv/bin/pytest -v