Event Flow

​

Event Flow Diagram

​

Event Sources

​

gRPC Slot Update

• Frequency: Approximately every 400ms (Solana slot time)
• Purpose: Triggers periodic cross detection for auction orders and limit orders
• Routing: Sent to both DLOBNotifier (for price updates) and the main loop (for processing)

new_slot = slot_rx.recv() => {
    slot = new_slot.expect("got slot update");
    // Check for auction and limit crosses in all markets
    for market in &market_ids {
        let crosses_and_top_makers = dlob.find_crosses_for_auctions(
            market_index, MarketType::Perp, slot, oracle_price, 
            Some(&perp_market), None
        );
        // ...
    }
}

​

gRPC Account Update

• User Accounts: Order placements, cancellations, fills, position changes
• Market Accounts: AMM state updates, liquidity changes
• Oracle Accounts: Price feed updates
• Routing: Sent to DLOBNotifier to update orderbook state

​

gRPC Transaction Update

• Confirmations: Transaction landed on-chain successfully
• Errors: Transaction failed or was rejected
• Routing: Sent directly to TxWorker.confirm_tx for processing

• Parse transaction logs to verify expected fills occurred
• Update metrics (success rate, fill rate, latency)
• Remove transactions from pending queue
• Detect competition scenarios (order already filled by others)

​

Swift Order WebSocket

• Source: WebSocket connection to Drift’s Swift order service
• Content: Signed order parameters with auction details
• Routing: Processed directly in the main loop
• Purpose: Provides low-latency opportunities to fill orders against resting liquidity

swift_order = swift_order_stream.next() => {
    match swift_order {
        Some(signed_order) => {
            let taker_order = TakerOrder::from_order_params(order_params, price);
            let crosses = dlob.find_crosses_for_taker_order(
                slot + 1, oracle_price, taker_order, 
                Some(&perp_market), None
            );
            if !crosses.is_empty() {
                try_swift_fill(/* ... */).await;
            }
        }
    }
}

​

DLOB and DLOBNotifier

​

DLOBNotifier

• Receives gRPC slot and account updates
• Batches events for efficient processing
• Parses account data to extract order information
• Emits DLOBEvent notifications for DLOB to consume

• SlotOrPriceUpdate: Triggers auction price recalculation
• OrderPlaced: Adds new resting order to DLOB
• OrderCancelled: Removes order from DLOB
• OrderFilled: Updates or removes filled order

​

DLOB (Orderbook State)

• Orders indexed by market, side (bid/ask), and price level
• User order mappings for quick lookups
• Efficient structures for cross detection queries

• find_crosses_for_auctions(): Finds auction orders that can be filled
• find_crosses_for_taker_order(): Matches taker against resting orders
• get_top_makers(): Queries best resting orders for liquidations

​

Main Loop Processing

loop {
    tokio::select! {
        biased;  // Process in order of definition
        swift_order = swift_order_stream.next() => {
            // Handle Swift orders first (highest priority)
        }
        new_slot = slot_rx.recv() => {
            // Handle slot updates (periodic cross detection)
        }
    }
}

​

Swift Order Priority

• They represent immediate opportunities
• Other bots may compete for the same fill
• Lower latency provides competitive advantage

​

Slot Update Processing

1. Update Oracle Prices: Fetch latest prices from DriftClient
2. Check Pyth Prices: Use faster Pyth Lazer feed if available
3. For Each Market:
   • Query DLOB for auction crosses
   • Filter crosses using slot limiter (avoid spam)
   • Build and submit fill transactions if crosses found
4. Calculate Priority Fee: Use percentile-based fee (50th-60th)
5. Add Entropy: Small random component to avoid duplicate tx hashes

​

Find Crosses

​

Auction Crosses

let crosses_and_top_makers = dlob.find_crosses_for_auctions(
    market_index,
    MarketType::Perp,
    slot,
    oracle_price,
    Some(&perp_market),
    None
);

• Auction orders where auction price crosses resting liquidity
• AMM (vAMM) opportunities where AMM wants to provide liquidity
• Top maker orders for each crossing taker

​

Swift Order Crosses

let crosses = dlob.find_crosses_for_taker_order(
    slot + 1,
    oracle_price as u64,
    taker_order,
    Some(&perp_market),
    None
);

​

Cross Filtering

crosses_and_top_makers.crosses.retain(|(o, _)| 
    limiter.allow_event(slot, o.order_id)
);

• Repeated attempts on the same order within a few slots
• Wasted transactions on orders that consistently fail
• Excessive priority fee spending

​

Transaction Building and Sending

​

try_auction_fill

1. Build Instruction: Create fill_perp_order instruction
2. Add Maker Accounts: Include all crossing maker accounts
3. Set Compute Budget: Priority fee + CU limit
4. Submit to TxWorker: Send via channel

​

try_swift_fill

1. Build Swift Fill Instruction: Include signed order data
2. Add Maker Accounts: Resting orders to match against
3. Set Compute Budget: Higher CU limit for Swift fills
4. Submit to TxWorker: Send via channel

​

TxWorker

let tx_worker = TxWorker::new(drift.clone(), metrics, config.dry);
let tx_worker_ref = tx_worker.run(rt);

1. Receive transaction request from channel
2. Sign transaction with wallet
3. Send to RPC endpoint
4. Add to PendingTxs buffer with metadata
5. Increment send metrics

1. Receive transaction update from gRPC
2. Look up transaction in PendingTxs by signature
3. Fetch full transaction details from RPC
4. Parse logs for fill events
5. Compare actual fills to expected intent
6. Update metrics (success, fill rate, latency)
7. Remove from pending buffer

​

Feedback Loop

• Learn Competition Patterns: Detect which orders are filled by others
• Optimize Priority Fees: Adjust fees based on success rate
• Monitor Performance: Track fill rates, latency, error types
• Detect Issues: Alert on high error rates or stale data