Performance Optimization

let priority_fee_subscriber = PriorityFeeSubscriber::new(
    drift.rpc().url(),
    &market_pubkeys  // Monitor fees for specific markets
);
let priority_fee_subscriber = priority_fee_subscriber.subscribe();

let pf = priority_fee_subscriber.priority_fee_nth(0.6);  // 60th percentile

let priority_fee = priority_fee_subscriber.priority_fee_nth(0.5) + slot % 2;
// 50th percentile + entropy for unique tx hash

let priority_fee = priority_fee_subscriber.priority_fee_nth(0.6);  // 60th percentile

let priority_fee = priority_fee_subscriber.priority_fee_nth(0.5) + slot % 2;

cargo run --release -- --mainnet --filler \
  --fill-cu-limit 400000 \
  --swift-cu-limit 350000

export FILL_CU_LIMIT=400000
export SWIFT_CU_LIMIT=350000

// Large accounts list, bump CU limit
if ix.accounts.len() >= 30 {
    tx_builder = tx_builder.set_ix(
        1,
        ComputeBudgetInstruction::set_compute_unit_limit(cu_limit * 2),
    );
}

if ix.accounts.len() >= 20 {
    tx_builder = tx_builder.set_ix(
        1,
        ComputeBudgetInstruction::set_compute_unit_limit(cu_limit * 2),
    );
}

if ix.accounts.len() >= 40 {
    tx_builder = tx_builder.set_ix(
        1,
        ComputeBudgetInstruction::set_compute_unit_limit((cu_limit * 25) / 10),
    );
}

let cus_spent = sent_cu_limit - meta.compute_units_consumed.unwrap();
metrics.cu_spent
    .with_label_values(&[intent_label])
    .observe(cus_spent as f64);

curl http://localhost:8080/metrics | grep cu_spent

const LIQUIDATION_SLOT_RATE_LIMIT: u64 = 5;  // ~2 seconds at 400ms/slot

if current_slot < liquidation_meta.slot + LIQUIDATION_SLOT_RATE_LIMIT {
    // Skip: too soon since last attempt
    continue;
}

pub struct OrderSlotLimiter<const N: usize> {
    slots: [Vec<u32>; N],  // Circular buffer of order IDs per slot
    generations: [u64; N],  // Slot number for each buffer index
}

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

// Check limit crosses every other slot
if slot % 2 == 0 {
    if let Some(crosses) = dlob.find_crossing_region(...) {
        try_uncross(...)
    }
}

pub struct PendingTxs<const N: usize> {
    buffer: [PendingTxMeta; N],
    head: usize,
    tail: usize,
    size: usize,
}

let confirmation_slots = tx_confirmed_slot - sent_slot;
metrics.confirmation_slots
    .with_label_values(&[intent_label])
    .observe(confirmation_slots as f64);

RpcSendTransactionConfig {
    skip_preflight: true,  // Faster sending
    max_retries: Some(0),  // No automatic retries
    ..Default::default()
}

market_ids.retain(|x| {
    let market = drift.program_data()
        .perp_market_config_by_index(x.index())
        .unwrap();
    let name = core::str::from_utf8(&market.name)
        .unwrap()
        .to_ascii_lowercase();

    // Exclude bet markets and initialized-only markets
    !name.contains("bet") && market.status != MarketStatus::Initialized
});

cargo run --release -- --mainnet --filler \
  --markets 0,1,2  # Only SOL-PERP, BTC-PERP, ETH-PERP

let mut market_ids = match config.use_markets() {
    UseMarkets::All => drift.get_all_perp_market_ids(),
    UseMarkets::Subset(m) => m,
};

events_rx.recv_many(&mut event_buffer, 64).await;
for event in event_buffer.drain(..) {
    // Process event
}

if oracle_update {
    for pubkey in &high_risk {  // Only check high-risk subset
        let margin_info = self.market_state
            .calculate_simplified_margin_requirement(...)?;
        
        let status = check_margin_status(&margin_info);
        if status.is_liquidatable() {
            liquidatable_users.push((pubkey, user, status));
        }
    }
}

const RECHECK_CYCLE_INTERVAL: u32 = 1024;

cycle_count += 1;
if cycle_count % RECHECK_CYCLE_INTERVAL == 0 {
    // Recheck all users
}

fill_actual / fill_expected

confirmation_slots{intent="auction_fill"}

cu_spent{intent="auction_fill"} / cu_limit

tx_confirmed / (tx_confirmed + tx_failed)

let priority_fee = if market_index == 0 {  // SOL-PERP
    priority_fee_subscriber.priority_fee_nth(0.7)  // Higher competition
} else {
    priority_fee_subscriber.priority_fee_nth(0.5)  // Standard
};

fn fixed_rate(feed_id: u32) -> FixedRate {
    match feed_id {
        1 | 2 | 6 => FixedRate::MIN,        // Fastest
        10 => FixedRate::from_ms(50),       // 50ms
        _ => FixedRate::from_ms(200),       // 200ms
    }
}

if margin_info.total_collateral < config.min_collateral as i128
    && margin_info.margin_requirement < config.min_collateral as u128 {
    // Skip account
}

cargo run --release -- --mainnet --liquidator \
  --min-collateral 1000000  # $1 minimum

let duration = std::time::SystemTime::now().duration_since(t0).unwrap().as_millis();
log::trace!("⏱️ checked fills at {slot}: {:?}ms", duration);

let t0 = current_time_millis();
// ... margin calculations ...
log::debug!("processed {} high-risk margin updates in {}ms",
    high_risk_count, current_time_millis() - t0);