Rust SDK

[dependencies]
# Inside the monorepo:
sequence-sdk = { path = "crates/sdk/sequence-sdk" }
 
# External consumer with access to the private repo:
# sequence-sdk = { git = "ssh://git@github.com/Bai-Funds/execution-engine.git", package = "sequence-sdk" }
 
tokio        = { version = "1", features = ["rt-multi-thread", "macros"] }
futures-util = "0.3"                                 # needed for StreamExt on the WS iterator

use sequence_sdk::{Sequence, Side, Urgency, Policy, SequenceError};
use sequence_sdk::builders::graph::{Node, Trigger, Sizing, FailureAction};
use sequence_sdk::builders::history::Range;
 
let seq = Sequence::new("seq_live_…")
    .base_url("https://api.sequencemkts.com");        // override for local dev

let seq = Sequence::new("seq_live_…");                          // production
let seq = Sequence::new("seq_test_…").base_url("http://localhost:50052");

match seq.buy("ETH-USD", 50.0).submit().await {
    Ok(ok)                                                       => …,
    Err(SequenceError::Api { status: 429, .. })                  => backoff().await,
    Err(SequenceError::Api { status: 409, message })             => kill_switch_check(&message),
    Err(SequenceError::CapabilityMissing { venue, reason, .. })  => eprintln!("{venue}: {reason}"),
    Err(e) => return Err(e.into()),
}

pub struct VenueCredentials {
    pub api_key:    String,
    pub api_secret: String,
    pub passphrase: Option<String>,         // OKX, Coinbase Advanced, Crypto.com, Bitget
    pub extra_json: Option<serde_json::Value>, // Polymarket signer material, HL vault, …
}

seq.connect_venue("kalshi", VenueCredentials {
    api_key:    "dc9d0cd5-076a-4ea8-b406-1847279dac4b".into(),
    api_secret: "-----BEGIN RSA PRIVATE KEY-----\nMIIE...\n-----END RSA PRIVATE KEY-----".into(),
    passphrase: None,
    extra_json: None,
}).await?;

seq.connect_venue("polymarket", VenueCredentials {
    api_key:    String::new(),                          // leave empty
    api_secret: String::new(),                          // leave empty
    passphrase: None,
    extra_json: Some(serde_json::json!({
        "signer_private_key": "0x…",                    // required
        "proxy_address":      "0x…",                    // optional
        "builder":            "0x…",                    // optional — builder-code recipient
    })),
}).await?;

pub struct Quote {
    pub symbol: String,
    pub nbbo:   QuoteNbbo,                            // bid, ask, mid, spread_bps
    pub venues: HashMap<String, QuoteVenue>,          // per-venue BBO with age_ms
    pub book:   Option<QuoteBook>,                    // merged L2 (bids, asks: Vec<BookLevel>)
    pub source: String,                               // "edge_nbbo" | "edge_rpc_snapshot" | "venue_public_api" | "unavailable"
}

let r = seq.quotes_batch(&[
    "BTC-USD",
    "4394372887385518214471608448209527405727552777602031099972143344338178308080",
    "KXNBA-26-TOR",
])
.depth(20)
.nowait(true)        // recommended for batches of 50+
.concurrency(64)     // cap 256
.send()
.await?;
 
for entry in r.quotes {
    match entry {
        BatchQuoteEntry::Ok(q)              => { /* q.source, q.nbbo, q.book */ }
        BatchQuoteEntry::Err { symbol, error } => eprintln!("{symbol}: {error}"),
    }
}

use sequence_sdk::InstrumentKind;
 
// All active positions across every venue
let resp = seq.positions_unified().fetch().await?;
println!("NAV = ${:.2}", resp.totals.nav_usd_1e9 as f64 / 1e9);
 
// Cash-only (fiat + crypto stablecoins)
let cash = seq.positions_unified()
    .kind(InstrumentKind::Fiat)
    .kind(InstrumentKind::Crypto)
    .fetch().await?;
 
// Or with the shorthand
let cash = seq.positions_unified().cash_only().fetch().await?;
 
// Event contracts on Kalshi + Polymarket
let events = seq.positions_unified()
    .events_only()
    .venue("kalshi")
    .venue("polymarket")
    .fetch().await?;

pub struct PriceHistoryQuery<'a> { … }
impl<'a> PriceHistoryQuery<'a> {
    pub fn range(self, range: Range) -> Self;          // default Range::OneDay
    pub fn fidelity_secs(self, secs: u64) -> Self;     // default 60; 0 = tick mode
    pub fn paginated(self) -> Self;                    // Polymarket 7-day windowing
    pub fn venue(self, v: impl Into<String>) -> Self;  // required for long-range CEX/DEX
    pub fn limit(self, n: u32) -> Self;                // tick-mode cap
    pub fn ticks(self, n: u32) -> Self;                // shorthand: fidelity_secs(0).limit(n)
    pub fn start_ts(self, s: u64) -> Self;             // explicit window in unix seconds
    pub fn end_ts(self, s: u64) -> Self;
    pub fn underlying(self) -> Self;                   // include Chainlink curve on PM crypto
    pub async fn fetch(self) -> Result<PriceHistory, SequenceError>;
}
 
pub enum Range {
    OneHour, SixHours, OneDay, OneWeek, OneMonth,
    ThreeMonths, SixMonths, OneYear, TwoYears, FiveYears, Max,
}
 
pub struct PriceHistory {
    pub symbol:     String,
    pub source:     String,                // "tape" | "polymarket_rest" | "kalshi_rest" |
                                           // "venue_proxy" | "venue_ticks" |
                                           // "binance_aggtrades_historical" | …
    pub window:     Option<PriceHistoryWindow>,
    pub points:     Vec<PricePoint>,
    pub underlying: Option<UnderlyingCurve>,
}
 
pub struct PricePoint {
    pub ts_ns:     u64,
    pub price_1e9: u64,
    pub qty_1e8:   Option<u64>,            // tick mode only
    pub side:      Option<String>,         // tick mode: "buy" | "sell"
    pub venue_id:  Option<u8>,             // tick mode: VenueId discriminant
}

// Year of Binance BTC-USDT 5-min bars
let btc = seq.price_history("BTC-USDT")
    .range(Range::OneYear).fidelity_secs(300).venue("binance")
    .fetch().await?;
 
// Last 500 tape prints with qty + side
let ticks = seq.price_history("BTC-USDC").ticks(500).fetch().await?;
 
// Polymarket 5-min lifecycle, include Chainlink underlying
let hist = seq.price_history("btc-updown-5m-1776537600")
    .fidelity_secs(0).limit(50_000).underlying()
    .fetch().await?;
if let Some(u) = hist.underlying {
    if u.agrees_with_settlement == Some(false) { /* drop for ML */ }
}

pub struct FundingRate {
    pub symbol:                      String,
    pub venue:                       String,
    pub dex:                         String,            // "" for CEX
    pub rate_bps_per_hour:           f64,
    pub predicted_rate_bps_per_hour: f64,
    pub mark_price_1e9:              i64,
    pub open_interest_1e8:           i64,
    pub next_settlement_ns:          u64,
    pub snapshot_age_ms:             u64,
}

pub struct SettlementQuery<'a> { … }
impl<'a> SettlementQuery<'a> {
    pub fn with_underlying(self) -> Self;      // include Chainlink curve (bounded RPC)
    pub async fn fetch(self) -> Result<Settlement, SequenceError>;
}
 
pub struct Settlement {
    pub slug: String, pub question: String,
    pub outcomes: Vec<String>,                 // native labels aligned with outcome_token_ids
    pub outcome_token_ids: Vec<String>,
    pub yes_token_id: String, pub no_token_id: String,
    pub condition_id: String, pub neg_risk: bool,
    pub status: String,                        // "open" | "resolving" | "resolved"
    pub resolved_outcome: Option<String>,      // ground truth from Polymarket (never reconstructed)
    pub outcome_source: String,
    pub yes_price: Option<f64>, pub no_price: Option<f64>,
    pub event_start_s: u64, pub event_end_s: u64,
    pub resolution_source: String,
    pub underlying: Option<UnderlyingSeries>,
}

impl<'a> MarketsQueryBuilder<'a> {
    pub fn slug(self, s: &str)       -> Self;
    pub fn search(self, q: &str)     -> Self;
    pub fn tag(self, t: &str)        -> Self;
    pub fn limit(self, n: u32)       -> Self;   // clamped [1, 1000] — server cap
    pub fn offset(self, n: u32)      -> Self;
    pub fn active_only(self, b: bool)-> Self;
    pub fn include_closed(self, b: bool) -> Self;
    pub fn order_by(self, field: &str)   -> Self;   // default = no sort. Options:
                                                    // volume | volume_week | volume_total |
                                                    // liquidity | end_date | start_date |
                                                    // created | competitive | closed_time
    pub fn cursor(self, c: &str)     -> Self;   // opaque cursor from prior next_cursor
    pub fn expand(self, modes: &str) -> Self;   // e.g. "outcomes"
 
    pub async fn fetch(self)     -> Result<MarketsResponse, SequenceError>;
    /// Walk every page that matches the current filters; threads
    /// `next_cursor` automatically. Forces page_size=1000 internally.
    pub async fn fetch_all(self) -> Result<Vec<Market>, SequenceError>;
}
 
pub struct MarketsResponse {
    pub markets: Vec<Market>,
    pub count: usize,
    pub venue: String,
    pub has_more: bool,                  // more pages remain
    pub next_cursor: Option<String>,     // pass back via .cursor(c)
}
 
pub struct Market {
    pub venue: String, pub slug: String, pub question: String,
    pub description: Option<String>,
    pub outcomes: Vec<String>, pub outcome_token_ids: Vec<String>,
    pub yes_token_id: String, pub no_token_id: String,
    pub condition_id: String, pub neg_risk: bool,
    pub volume_24h: f64, pub volume_week: f64, pub volume_total: f64, pub liquidity: f64,
    pub end_date: Option<String>, pub start_date: Option<String>,
    pub url: String,
}

// Whole open Kalshi universe (~43k rows, ~4 s).
let all = seq.markets("kalshi").active_only(true).fetch_all().await?;
 
// Manual cursor — for streaming / progress reporting.
let p1 = seq.markets("kalshi").active_only(true).limit(1000).fetch().await?;
if let Some(c) = p1.next_cursor.as_deref() {
    let p2 = seq.markets("kalshi").active_only(true).limit(1000)
        .cursor(c).fetch().await?;
}

let resp = seq.fees("KXMLBHR-26APR292140KCATH-ATHLBUTLER4-1:YES")
    .venues(&["kalshi", "polymarket"])
    .fetch().await?;
for row in &resp.fees {
    println!("{} taker={:?} maker={:?}", row.venue, row.taker_bps, row.maker_bps);
}

impl<'a> OrderBuilder<'a> {
    pub fn venue(self, v: &str)              -> Self;   // pin to one venue (else SOR)
    pub fn limit_price(self, px: f64)        -> Self;   // omit for market order
    pub fn policy(self, p: Policy)           -> Self;   // default Policy::Sor
    pub fn urgency(self, u: Urgency)         -> Self;   // Low | Medium | High
    pub fn max_slippage_bps(self, bps: u16)  -> Self;
    pub fn horizon_ms(self, ms: u64)         -> Self;
    pub fn time_in_force(self, t: TimeInForce) -> Self; // Gtc | Ioc | Fok
    pub fn perp(self)                        -> Self;   // instrument_type = "perp"
    pub fn sandbox(self)                     -> Self;   // paper fill against live book
    pub async fn submit(self) -> Result<SubmitGraphResponse, SequenceError>;
}
 
pub enum Side     { Buy, Sell }
pub enum Urgency  { Low, Medium, High }
pub enum Policy   { Sor, IocSweep, PassiveLimit, AggressiveChase, PassiveLadder, TimeDrip }
pub enum TimeInForce { Gtc, Ioc, Fok }
 
pub struct SubmitGraphResponse {
    pub graph_id:   String,
    pub status:     String,
    pub node_count: usize,
    pub edge_count: usize,
}

seq.buy("ETH-USD", 50.0)
    .urgency(Urgency::High)
    .max_slippage_bps(10)
    .submit().await?;
 
seq.sell("BTC-USD", 0.5)
    .venue("coinbase")
    .limit_price(75_000.0)
    .time_in_force(TimeInForce::Gtc)
    .submit().await?;
 
seq.buy("ETH-USD-PERP", 5.0)
    .perp()
    .venue("hyperliquid")
    .submit().await?;
 
// Paper fill against live book — works on seq_live_*
seq.buy("SOL-USD", 100.0).sandbox().submit().await?;

pub struct OrderResponse {
    pub node_order_id: String,
    pub client_id: String,
    pub client_order_id: Option<String>,
    pub side: String,                     // "BUY" / "SELL" — UPPERCASE
    pub symbol: String,
    pub qty_1e8: i64, pub filled_qty_1e8: i64,
    pub status: String,                   // "NEW" | "PENDING" | "ACCEPTED" | "PARTIAL" |
                                          // "FILLED" | "COMPLETED" | "CANCELLED" |
                                          // "REJECTED" | "FAILED"
    pub constraints: Option<serde_json::Value>,
    pub created_unix_ns: Option<u64>, pub updated_unix_ns: Option<u64>,
    pub failure_reason:  Option<String>,
    pub tca: Option<TcaReport>,
}
impl OrderResponse {
    pub fn qty(&self)         -> f64;     // qty_1e8 / 1e8
    pub fn filled_qty(&self)  -> f64;
    pub fn fill_pct(&self)    -> f64;     // 0.0–100.0
    pub fn is_terminal(&self) -> bool;    // COMPLETED | CANCELLED | FAILED
}

let page = seq.orders().await
    .symbol("ETH-USD").limit(100).offset(0)
    .fetch().await?;
// OrdersResponse { orders, total, limit, offset, has_more }

pub enum AmendMode { NativeAtomic, CancelReplace }
 
pub struct AmendResult {
    pub order_id: String,        // new id on CancelReplace; same on NativeAtomic
    pub mode:     AmendMode,
    pub status:   Option<String>,
}

pub enum DecreaseMode { Native, CancelReplaceShrink }
pub struct DecreaseResult { pub order_id: String, pub mode: DecreaseMode, pub status: Option<String> }

impl<'a> BatchBuilder<'a> {
    pub fn emulate(self) -> Self;                                // compatibility no-op; batch mode stays Serial
    pub fn buy (self, sym: &str, qty: f64)                -> Self;
    pub fn sell(self, sym: &str, qty: f64)                -> Self;
    pub fn buy_limit (self, sym: &str, qty: f64, px: f64) -> Self;
    pub fn sell_limit(self, sym: &str, qty: f64, px: f64) -> Self;
    pub fn cancel(self, order_id: &str)                   -> Self;
    pub fn len(&self) -> usize;  pub fn is_empty(&self) -> bool;
    pub async fn end(self) -> Result<BatchResult, SequenceError>;
}
 
pub enum BatchMode { NativeAtomic, Serial }
 
pub enum BatchItemResult {
    Submitted(SubmitGraphResponse),
    Cancelled(String),
    Error(String),
}
 
pub struct BatchResult { pub responses: Vec<BatchItemResult>, pub mode: BatchMode }

// Kalshi — ok by default
let r = seq.batch("kalshi")
    .buy_limit("KXBTCZ-26DEC31-T99000",  10.0, 0.55)
    .buy_limit("KXBTCZ-26DEC31-T100000", 10.0, 0.50)
    .cancel("stale_order_id")
    .end().await?;
assert_eq!(r.mode, BatchMode::Serial);
 
// Polymarket — graph-level SDK batch is serial today
let r = seq.batch("polymarket").buy("TOKEN_ID", 10.0).end().await?;
assert_eq!(r.mode, BatchMode::Serial);

pub enum RedeemMode { AutoSettled, RelayerSubmitted, Noop }
 
pub struct RedeemResult {
    pub mode:         RedeemMode,
    pub venue:        String,
    pub slug:         String,
    pub condition_id: Option<String>,   // Polymarket only
    pub token_ids:    Option<Vec<String>>, // Polymarket only
    pub note:         String,
}

impl<'a> GraphBuilder<'a> {
    pub fn node(self, id: &str, node: Node) -> Self;
    pub fn edge(self, from: &str, to: &str, trigger: Trigger) -> Self;
    pub fn edge_with(self, from: &str, to: &str, trigger: Trigger,
                     f: impl FnOnce(EdgeConfig) -> EdgeConfig) -> Self;
    pub fn risk(self, f: impl FnOnce(RiskConfig) -> RiskConfig) -> Self;
    pub fn sandbox(self) -> Self;
    pub fn metadata(self, m: serde_json::Value) -> Self;
    pub async fn submit(self) -> Result<SubmitGraphResponse, SequenceError>;
}

impl Node {
    pub fn buy (symbol: &str, qty: f64) -> Self;
    pub fn sell(symbol: &str, qty: f64) -> Self;
 
    // Venue + instrument
    pub fn venue(self, v: &str)        -> Self;
    pub fn perp(self)                  -> Self;        // instrument_type = "perp"
    pub fn prediction(self)            -> Self;        // instrument_type = "prediction"
 
    // Execution config
    pub fn limit_price(self, px: f64)    -> Self;
    pub fn policy(self, p: Policy)       -> Self;
    pub fn urgency(self, u: Urgency)     -> Self;
    pub fn max_slippage_bps(self, b: u16)-> Self;
    pub fn horizon_ms(self, ms: u64)     -> Self;
    pub fn tif(self, t: &str)            -> Self;       // "GTC" | "IOC" | "FOK"
    pub fn reduce_only(self)             -> Self;       // close existing position only
    pub fn derived(self)                 -> Self;       // qty derived from inbound edge sizing
 
    // Pacing (sub-graph expansion under the hood)
    pub fn twap(self, slices: u16, interval_ms: u64)    -> Self;
    pub fn vwap(self, slices: u16, interval_ms: u64)    -> Self;
    pub fn iceberg(self, display_qty: f64)              -> Self;
 
    // Atomic overrides
    pub fn placement(self, s: &str)            -> Self; // "aggressive" | "passive" | "passive_offset"
    pub fn escalate_after(self, ms: u64)       -> Self; // cross spread after N ms
    pub fn venue_fallback(self, v: &[&str])    -> Self; // priority-ordered venues
}

pub enum Trigger {
    FillPct(f64),                      // 0.0–1.0
    FirstFill,
    OnFill,                            // every fill (streaming hedge)
    FullFill,
    OnAccepted,                        // SOR ACKed
    Timeout(u64),                      // ms
    OnCancel,
    OnDone,                            // any terminal state
    OnPrice { symbol: String, direction: String, offset_pct: f64 },
}

pub enum Sizing {
    ParentFilledQty,                   // use parent's cumulative filled qty
    IncrementalFill,                   // only the delta since last edge fire
    LinearHedge(f64),                  // multiplier; -1.0 = opposite-side 1:1 hedge
    ScaledNotional { multiplier: f64, cap_usd: Option<f64> },
    Residual,                          // parent target - parent filled
    Fixed(f64),                        // ignore parent entirely
}

impl EdgeConfig {
    pub fn sizing(self, s: Sizing)                -> Self;
    pub fn on_parent_cancel(self, action: &str)   -> Self;   // "cancel_all_open" | "pause_graph" | "do_nothing"
    pub fn on_child_reject (self, action: &str)   -> Self;
}

impl RiskConfig {
    // Layer 1: Admission — evaluated before any order leaves
    pub fn max_notional_usd(self, usd: f64)       -> Self;
    pub fn max_leverage(self, lev: f64)           -> Self;
    pub fn required_venues(self, v: &[&str])      -> Self;
    pub fn max_concurrent_graphs(self, n: u32)    -> Self;
 
    // Layer 2: Pre-trade — per-node gates
    pub fn max_node_notional_usd(self, usd: f64)  -> Self;
    pub fn require_balance_check(self)            -> Self;
    pub fn max_slippage_bps(self, bps: u16)       -> Self;
 
    // Layer 3: Runtime — continuously enforced while the graph executes
    pub fn max_unhedged_qty(self, qty: f64)       -> Self;
    pub fn max_loss_usd(self, usd: f64)           -> Self;
    pub fn max_drawdown_usd(self, usd: f64)       -> Self;
 
    // Layer 4: Failure — what to do on breach
    pub fn on_runtime_breach(self, a: FailureAction) -> Self;
    pub fn on_disconnect   (self, a: FailureAction) -> Self;
}
 
pub enum FailureAction {
    CancelAll,          // serialized as "cancel_all_open"
    CancelPending,      // serialized as "cancel_all_open" (alias today)
    Pause,              // "pause_graph"
    Continue,           // "do_nothing"
}

// Spot + perp hedge with 4-layer risk
seq.graph()
    .node("spot",  Node::buy ("ETH-USD",      200.0).policy(Policy::Sor))
    .node("hedge", Node::sell("ETH-USD-PERP", 200.0).perp().venue("hyperliquid"))
    .edge("spot", "hedge", Trigger::FillPct(0.5))
    .risk(|r| r
        .max_notional_usd(500_000.0)
        .max_unhedged_qty(5.0)
        .on_runtime_breach(FailureAction::CancelAll))
    .submit().await?;
 
// TWAP — 10 slices, 30s apart
seq.graph()
    .node("twap", Node::buy("BTC-USD", 1.0).twap(10, 30_000))
    .submit().await?;
 
// Streaming hedge — every fill triggers proportional perp sell
seq.graph()
    .node("spot",  Node::buy ("ETH-USD",  100.0))
    .node("hedge", Node::sell("ETH-PERP",   0.0).perp().derived())
    .edge_with("spot", "hedge", Trigger::OnFill,
               |e| e.sizing(Sizing::LinearHedge(-1.0)))
    .submit().await?;
 
// Bracket — entry → take-profit + stop-loss
seq.graph()
    .node("entry", Node::buy ("BTC-USD", 0.1))
    .node("tp",    Node::sell("BTC-USD", 0.0).derived().limit_price(80_000.0))
    .node("sl",    Node::sell("BTC-USD", 0.0).derived())
    .edge("entry", "tp", Trigger::FullFill)
    .edge("entry", "sl", Trigger::OnPrice {
        symbol: "BTC-USD".into(), direction: "below".into(), offset_pct: -5.0,
    })
    .risk(|r| r.max_loss_usd(2_000.0).on_runtime_breach(FailureAction::CancelAll))
    .submit().await?;

pub struct GraphStatusResponse {
    pub graph_id: String,
    pub client_id: String,
    pub status: String,                      // pending | active | partial_fill | completed |
                                             // aborted | expired | paused
    pub nodes: HashMap<String, NodeStatus>,
    pub edges: HashMap<String, EdgeStatus>,
}
pub struct NodeStatus {
    pub status: String,                      // pending | armed | executing | filled |
                                             // partial_fill | cancelled | rejected
    pub node_order_id: Option<String>,
    pub target_qty_1e8: i64, pub filled_qty_1e8: i64,
    pub avg_fill_price_1e9: i64, pub fill_count: u64,
}
pub struct EdgeStatus { pub status: String, pub fired: bool }

pub struct Deployment {
    pub deployment_id: String,
    pub name: Option<String>,
    pub symbols: Vec<String>,
    pub size_bytes: u64,
    pub status: String,
    pub pushed_to: usize,            // edges that accepted the push
    pub capable_edges: usize,        // edges that *could* host this algo
    pub edges: Vec<DeploymentEdge>,  // per-edge runtime state
}
pub struct DeploymentEdge {
    pub edge_id: String, pub venue: String, pub status: String,
    pub position_1e8: i64, pub realized_pnl_1e9: i64, pub unrealized_pnl_1e9: i64,
    pub fill_count: u64, pub callback_latency_ns: u64,
}

seq.algos().await?;                          // GET /v1/algos
seq.algos_per_edge().await?;                 // GET /v1/algos?detail=edge
seq.algo("ETH-USD").await?;                  // GET /v1/algos/:symbol
seq.algo_start_by_symbol("ETH-USD").await?;
seq.algo_stop_by_symbol("ETH-USD").await?;
seq.algo_logs_by_symbol("ETH-USD").await?;
seq.algo_stats("ETH-USD").await?;

seq.strategies().await?;                     // GET /v1/strategies
seq.strategy("strat_abc").await?;            // GET /v1/strategies/:id
seq.strategy_start("strat_abc").await?;
seq.strategy_stop("strat_abc").await?;
seq.strategy_logs("strat_abc").await?;
seq.strategy_delete("strat_abc").await?;

pub struct TraceEvent {
    pub event_type: String,             // "admitted" | "routed" | "edge_submitted" |
                                        // "venue_acked" | "first_fill" | "completed" | …
    pub timestamp_ns: u64,
    pub venue: Option<String>,
    pub detail: Option<String>,
}

impl<'a> StreamBuilder<'a> {
    pub fn orders(self, yes: bool)  -> Self;    // subscribe to `orders`
    pub fn fills (self, yes: bool)  -> Self;    // subscribe to `fills`
    pub fn routing(self, yes: bool) -> Self;    // subscribe to `routing`
    pub fn book(self, yes: bool)    -> Self;    // subscribe to `book:{sym}` for each sym
    pub async fn connect(self) -> Result<MarketDataStream, SequenceError>;
}
 
pub enum StreamEvent {
    Price { symbol: String, data: serde_json::Value },   // channel "prices:{sym}"
    Book  { symbol: String, data: serde_json::Value },   // channel "book:{sym}"
    Order (serde_json::Value),                           // channel "orders"
    Fill  (serde_json::Value),                           // channel "fills"
    Routing(serde_json::Value),                          // channel "routing"
    Trace { deployment_id: String, data: serde_json::Value },  // channel "traces:{dep_id}"
    Raw   { channel: String, data: serde_json::Value },  // anything we don't specifically parse
}

use futures_util::StreamExt;
 
let mut s = seq.stream(&["BTC-USD", "ETH-USD"])
    .orders(true).fills(true).book(true)
    .connect().await?;
 
while let Some(evt) = s.next().await {
    match evt? {
        StreamEvent::Price { symbol, data } => println!("{symbol}: {data}"),
        StreamEvent::Fill (fill)            => println!("fill:  {fill}"),
        StreamEvent::Order(order)           => println!("order: {order}"),
        StreamEvent::Book { symbol, data }  => println!("{symbol} L2: {data}"),
        StreamEvent::Routing(r)             => println!("routing: {r}"),
        StreamEvent::Trace { deployment_id, data } => println!("{deployment_id}: {data}"),
        StreamEvent::Raw   { channel, data } => println!("[{channel}] {data}"),
    }
}

pub struct LifecycleStream { … }
impl LifecycleStream {
    pub async fn next(&mut self) -> Result<Option<serde_json::Value>, SequenceError>;
}
 
// Every freshly-minted market — already carries tick + fee schedule
let mut s = seq.stream_new_markets().await?;
while let Some(ev) = s.next().await? {
    if ev["slug"].as_str().unwrap_or("").contains("btc-updown") {
        let tok = ev["outcome_token_ids"][0].as_str().unwrap();
        seq.buy(tok, 5.0).venue("polymarket").submit().await?;
    }
}
 
// Every resolution — winning token paid $1, losing token paid $0
let mut s = seq.stream_resolved_markets().await?;
while let Some(ev) = s.next().await? { /* … */ }

use sequence_sdk::{Qty, Px};
 
let qty = Qty::from_human(1.5);      // stores 150_000_000
assert_eq!(qty.human(), 1.5);
 
let px  = Px::from_human(74_000.0);  // stores 74_000_000_000_000
assert_eq!(px.human(), 74_000.0);

let resp = seq.positions_unified().fetch().await?;
for v in &resp.positions {
    let qty        = v.qty_1e8 as f64 / 1e8;
    let entry      = v.entry_price_usd_1e9 as f64 / 1e9;
    let unrealized = v.unrealized_pnl_usd_1e9 as f64 / 1e9;
    println!("{:?}  qty={} entry=${:.2} P&L=${:+.2}",
             v.instrument, qty, entry, unrealized);
}