Rust SDK#

[dependencies]
seesaw-sdk = "0.1.0-rc.1"           # or: { path = "packages/sdk-rust" } from the monorepo
solana-pubkey = "2.2"
solana-instruction = "2.2"

# Trustless layer (depends on seesaw-sdk; default feature "http" = ureq transport):
seesaw-trustless = { path = "packages/trustless-rust" }

seesaw-sdk = { version = "0.1.0-rc.1", features = ["http"] }
seesaw-sdk = { version = "0.1.0-rc.1", features = ["rpc"] }

use seesaw_sdk::constants::PROGRAM_ID;
use seesaw_sdk::pda::{derive_market_pda, pick_treasury_index};
use seesaw_sdk::instructions::{place_order, PlaceOrderAccounts};
use seesaw_sdk::types::{OrderSide, OrderType, PlaceOrderParams};
use seesaw_sdk::codecs::decode_market;
use solana_pubkey::Pubkey;

const TOKEN_PROGRAM: Pubkey =
    Pubkey::from_str_const("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA");
const SYSTEM_PROGRAM: Pubkey =
    Pubkey::from_str_const("11111111111111111111111111111111");

// 1. Derive a market PDA
let feed_id = [0xAB_u8; 32];
let (market_pda, _bump) = derive_market_pda(&feed_id, 900, 1, &creator, &PROGRAM_ID);

// 2. Decode a market account from raw bytes
let market = decode_market(&account_data)?;
println!("Market state: {:?}, outcome: {:?}", market.state, market.outcome);
let current_slot = 12_345; // Fetch the current slot from your Solana RPC client.
let treasury_index = pick_treasury_index(&wallet.pubkey(), current_slot, 8);

// 3. Build a PlaceOrder instruction (18 accounts, in on-chain order)
let params = PlaceOrderParams {
    side: OrderSide::BuyYes,
    price_bps: 5000,         // 50%
    quantity: 100_000_000,   // 100 USDT (6 decimals)
    order_type: OrderType::Limit,
    worst_acceptable_price_bps: 0,
    min_fill_quantity: 0,
    match_limit: 0,
    self_trade_behavior: 1,
    max_age_seconds: 0,
    reject_post_only_would_cross: 1,
    protocol_treasury_index: treasury_index, // must match treasury_token_account below
};
let accounts = PlaceOrderAccounts {
    market: market_pda,
    orderbook: orderbook_pda,
    user_position: position_pda,
    user_token_account: user_stablecoin_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,
    system_program: SYSTEM_PROGRAM,
    settlement_mint,
    yes_escrow: yes_escrow_pda,
    no_escrow: no_escrow_pda,
    user_yes_ata,
    user_no_ata,
    yes_mint: yes_mint_pda,
    no_mint: no_mint_pda,
    trader_ledger: trader_ledger_pda,
};
let ix = place_order(&accounts, &params, &PROGRAM_ID);
// Add ix to a transaction and send

use seesaw_sdk::instructions::{create_market_bundle, CreateMarketAccounts};
use seesaw_sdk::types::{CreateMarketParams, MarketSizeParams};

let params = CreateMarketParams {
    max_confidence_ratio_bps: 500, // 5%; 0 disables the confidence guard
    duration_seconds: 900,         // 15-minute market
    max_oracle_jump_bps: 0,        // 0 = protocol default jump guard (5,000 bps)
    market_size_params: MarketSizeParams {
        bids_size: 512, // deep-orderbook tier: 64, 128, 256, 512, 1024, 2048, or 4096
        asks_size: 512, // must match bids_size
        num_seats: 128,
    },
    oracle_mode: 1, // launch default: 1 = Pyth pull; 0 = legacy-compatible Pyth push
};

// Returns Vec<Instruction>: EnsureTraderLedgerSpace prelude(s) +
// EnsureDeepOrderbookSpace prelude(s) + CreateMarket. Submit in order.
// For large/max seat or orderbook tiers, split the preludes across
// transactions and emit CreateMarket (the last entry) in the final one.
let instructions = create_market_bundle(&accounts, &params, &PROGRAM_ID);

use seesaw_sdk::constants::PROGRAM_ID;
use seesaw_sdk::instructions::{place_order, PlaceOrderAccounts};
use seesaw_sdk::types::{OrderSide, OrderType, PlaceOrderParams};
use seesaw_trustless::{
    list_markets, HttpTransport, ResolvePlaceOrderParams, TrustlessResolver, TrustlessRpc,
    SYSTEM_PROGRAM_ADDRESS, TOKEN_PROGRAM_ADDRESS,
};

let rpc = TrustlessRpc::new(HttpTransport::new("https://your-node.example"));
let resolver = TrustlessResolver::new(&rpc);

// Discover markets straight from chain state (no Seesaw API).
let markets = list_markets(&rpc, &PROGRAM_ID)?;

// 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.
let r = resolver.resolve_place_order(&ResolvePlaceOrderParams::new(markets.value[0].address, user))?;
let t = r.accounts.trading;

let ix = place_order(
    &PlaceOrderAccounts {
        market: t.market,
        orderbook: t.orderbook,
        user_position: t.user_position,
        user_token_account: t.user_token_account,
        vault: t.vault,
        user,
        config: r.accounts.config,
        treasury_token_account: r.accounts.treasury_token_account,
        token_program: TOKEN_PROGRAM_ADDRESS,
        system_program: SYSTEM_PROGRAM_ADDRESS,
        settlement_mint: t.settlement_mint,
        yes_escrow: t.yes_escrow,
        no_escrow: t.no_escrow,
        user_yes_ata: t.user_yes_ata,
        user_no_ata: t.user_no_ata,
        yes_mint: t.yes_mint,
        no_mint: t.no_mint,
        trader_ledger: t.trader_ledger,
    },
    &PlaceOrderParams {
        side: OrderSide::BuyYes,
        price_bps: 6_500,
        quantity: 1_000_000,
        order_type: OrderType::Limit,
        worst_acceptable_price_bps: 0,
        min_fill_quantity: 0,
        match_limit: 0,
        self_trade_behavior: 1,
        max_age_seconds: 0,
        reject_post_only_would_cross: 1,
        protocol_treasury_index: r.protocol_treasury_index,
    },
    &PROGRAM_ID,
);
// Assemble [r.prepend_instructions..., ix] into one transaction, simulate
// via rpc.simulate_transaction(&base64_tx), then sign & send.

let balances = resolver.get_trader_balances(&market, &user)?.value; // ledger buckets
let orders = resolver.find_user_orders(&market, &user)?.value;      // resting orders
let position = resolver.get_position(&market, &user)?.value;
let status = resolver.get_referral_status(&user, resolver.get_chain_unix_timestamp()?)?;

use seesaw_sdk::referral::{resolve_referrer, ReferrerInput, IndexerSnapshot, ReferrerSource};
use seesaw_sdk::creator::list_creator_markets;
use solana_pubkey::Pubkey;
use std::str::FromStr;

let wallet = Pubkey::from_str("5Q544fKrFoe6tsEbD7S8EmxGTJYAKtTVhAW5Q5pge4j1")?;
let referrer = Pubkey::from_str("11111111111111111111111111111112")?;

let input = ReferrerInput {
    wallet,
    indexer_snapshot: Some(IndexerSnapshot {
        referrer: referrer.to_string(),
        expires_at_ms: 4_070_908_800_000,
    }),
    rpc_snapshot: None,
    pending_referrer: None,
    earnings_exists: true,
};

let resolution = resolve_referrer(&input);
assert_eq!(resolution.source, ReferrerSource::Indexer);
// Attach trailing accounts to place_order only after checking:
// if resolution.eligible_for_triple { ... }

// list_creator_markets parses the creators endpoint JSON
let entries = list_creator_markets(&raw_json)?;
let claimable: Vec<_> = entries.iter().filter(|e| e.claimable_now).collect();

cd packages/sdk-rust
cargo test