Write algos. Compile to WASM. Deploy to the edge.

curl -fsSL https://raw.githubusercontent.com/Bai-Funds/algo-sdk/main/install.sh | sh
sequence login

[package]
name = "my-algo"
version = "0.1.0"
edition = "2021"
 
[lib]
crate-type = ["cdylib"]
 
[dependencies]
sequence-algo-sdk = { version = "0.3", default-features = false }
 
[profile.release]
opt-level = "z"
lto = true
codegen-units = 1
panic = "abort"

rustup target add wasm32-unknown-unknown

pub trait Algo: Send {
    /// Called on every order book update (100-1000+ times/second).
    fn on_book(
        &mut self,
        book: &L2Book,
        state: &AlgoState,
        features: &OnlineFeatures,
        actions: &mut Actions,
    );
 
    /// Called when your order fills. Default: no-op.
    fn on_fill(&mut self, _fill: &Fill, _state: &AlgoState) {}
 
    /// Called when your order is rejected. Default: no-op.
    fn on_reject(&mut self, _reject: &Reject) {}
 
    /// Shutdown — cancel orders and flatten here. Default: no-op.
    fn on_shutdown(&mut self, _state: &AlgoState, _actions: &mut Actions) {}
 
    /// Heartbeat (1 Hz, optional). Default: no-op.
    fn on_heartbeat(
        &mut self,
        _state: &AlgoState,
        _features: &OnlineFeatures,
        _actions: &mut Actions,
    ) {}
 
    /// Mesh: message from another instance. Default: no-op.
    fn on_message(
        &mut self,
        _from: &str,
        _payload: &[u8],
        _state: &AlgoState,
        _actions: &mut Actions,
    ) {}
 
    /// Mesh: cross-venue NBBO. Default: no-op.
    fn on_nbbo(
        &mut self,
        _nbbo: &NbboSnapshot,
        _books: &VenueBooks,
        _state: &AlgoState,
        _features: &OnlineFeatures,
        _actions: &mut Actions,
    ) {}
}

use algo_sdk::*;
 
struct MyArb { /* ... */ }
 
impl Algo for MyArb {
    fn on_book(&mut self, book: &L2Book, state: &AlgoState,
               features: &OnlineFeatures, actions: &mut Actions) {
        // Act on local book. Send an intent to the hedger instance if needed.
        // messaging::send("hedger", &payload);
    }
 
    fn on_nbbo(&mut self, nbbo: &NbboSnapshot, books: &VenueBooks,
               state: &AlgoState, features: &OnlineFeatures,
               actions: &mut Actions) {
        // Cross-venue visibility — spot cross-market opportunities.
    }
 
    fn on_message(&mut self, from: &str, payload: &[u8],
                  state: &AlgoState, actions: &mut Actions) {
        // Another instance told us something. React locally.
    }
}
 
export_algo!(MyArb { /* ... */ });

// Access per-venue depth
if let Some(kraken) = books.book_for_venue(VENUE_KRAKEN) {
    log_info!("kraken: {} bids, {} asks, mid={}",
        kraken.bid_ct, kraken.ask_ct, kraken.mid_px_1e9());
}
 
// Use merged cross-venue depth for sizing
let total_bid_depth = books.merged.bid_depth_1e8(5); // top 5 levels

let pool_books = unsafe { &*(POOL_BOOKS_WASM_OFFSET as *const PoolBooks) };

use algo_sdk::*;
 
struct MyAlgo {
    next_id: u64,
}
 
impl Algo for MyAlgo {
    fn on_book(
        &mut self,
        book: &L2Book,
        state: &AlgoState,
        _features: &OnlineFeatures,
        actions: &mut Actions,
    ) {
        // Your trading logic here
        if book.spread_bps() > 10 && state.is_flat() {
            self.next_id += 1;
            actions.buy(self.next_id, 10_000_000, book.bids[0].px_1e9);
        }
    }
 
    fn on_fill(&mut self, fill: &Fill, state: &AlgoState) {
        log_info!("Filled {} @ {}, pos={}",
            fill.qty_1e8, fill.px_1e9, state.position_1e8);
    }
 
    fn on_reject(&mut self, reject: &Reject) {
        log_warn!("Rejected: {} - {}", reject.order_id, reject.reason());
    }
 
    fn on_shutdown(&mut self, state: &AlgoState, actions: &mut Actions) {
        actions.cancel_all(state);
    }
}
 
// This macro generates the WASM exports
export_algo!(MyAlgo { next_id: 0 });

// Price: $50,000.50 -> 50_000_500_000_000
let price_1e9 = 50_000_500_000_000u64;
let price_f64 = price_1e9 as f64 / 1e9; // 50000.5
 
// Quantity: 1.5 BTC -> 150_000_000
let qty_1e8 = 150_000_000i64;
let qty_f64 = qty_1e8 as f64 / 1e8; // 1.5
 
// Spread: 5 bps -> 0.05%
let spread_bps = 5u32;
let spread_pct = spread_bps as f64 / 100.0; // 0.05

sequence init my-algo && cd my-algo
sequence build
sequence deploy BTC-USD --start

// Direct array access (fast)
let bid_px = book.bids[0].px_1e9;
 
// Pre-compute values
let threshold = self.config.spread_bps;
 
// Early returns
if book.spread_bps() < 5 { return; }

// Heap allocation (slow)
let prices: Vec<u64> = book.bids.iter().map(|l| l.px_1e9).collect();
 
// String formatting in hot path
let msg = format!("Price: {}", book.bids[0].px_1e9); // Allocates!
 
// Complex computation every tick
let vwap = calculate_vwap_from_scratch(); // Cache this

use algo_sdk::*;
 
struct SpeedTest {
    next_id: u64,
    trips_target: u32,
    trips_completed: u32,
    current_trip: u32,
    awaiting_buy_fill: bool,
    awaiting_sell_fill: bool,
    size_1e8: i64,
    buy_times: [u64; 10],
    sell_times: [u64; 10],
    last_order_ns: u64,
}
 
impl Algo for SpeedTest {
    fn on_book(
        &mut self,
        book: &L2Book,
        _state: &AlgoState,
        _features: &OnlineFeatures,
        actions: &mut Actions,
    ) {
        if self.trips_completed >= self.trips_target { return; }
        if self.awaiting_buy_fill || self.awaiting_sell_fill { return; }
        
        // Start new trip with a buy
        self.current_trip = self.trips_completed;
        self.next_id += 1;
        self.last_order_ns = book.recv_ns;
        self.awaiting_buy_fill = true;
        
        actions.market_buy(self.next_id, self.size_1e8);
        log_info!("BUY: trip={} order={}", self.current_trip + 1, self.next_id);
    }
 
    fn on_fill(&mut self, fill: &Fill, _state: &AlgoState) {
        let latency_ns = fill.recv_ns.saturating_sub(self.last_order_ns);
        let latency_ms = latency_ns / 1_000_000;
        
        if self.awaiting_buy_fill {
            self.buy_times[self.current_trip as usize] = latency_ms;
            self.awaiting_buy_fill = false;
            self.awaiting_sell_fill = true;
            
            // Immediately sell
            self.next_id += 1;
            self.last_order_ns = fill.recv_ns;
            log_warn!("BUY FILL: latency={}ms, sending SELL", latency_ms);
            
        } else if self.awaiting_sell_fill {
            self.sell_times[self.current_trip as usize] = latency_ms;
            self.awaiting_sell_fill = false;
            self.trips_completed += 1;
            
            let buy_ms = self.buy_times[self.current_trip as usize];
            let total_ms = buy_ms + latency_ms;
            log_warn!("ROUND TRIP #{}: {}ms (buy={}ms sell={}ms)",
                self.trips_completed, total_ms, buy_ms, latency_ms);
        }
    }
 
    fn on_reject(&mut self, reject: &Reject) {
        log_error!("REJECT: {}", reject.reason());
        self.awaiting_buy_fill = false;
        self.awaiting_sell_fill = false;
    }
    
    fn on_shutdown(&mut self, state: &AlgoState, actions: &mut Actions) {
        actions.cancel_all(state);
        log_warn!("=== FINAL: {} trips completed ===", self.trips_completed);
    }
}
 
export_algo!(SpeedTest {
    next_id: 5000,
    trips_target: 5,
    trips_completed: 0,
    current_trip: 0,
    awaiting_buy_fill: false,
    awaiting_sell_fill: false,
    size_1e8: 200_000_000, // 2 units
    buy_times: [0; 10],
    sell_times: [0; 10],
    last_order_ns: 0,
});