Backtesting Solana Trading Strategies with Historical Raw Blocks (2026)

import json
import sys
from pathlib import Path

VOTE_PROGRAM = "Vote111111111111111111111111111111111111111"


def load_block(path: str) -> dict:
    with open(path) as f:
        return json.load(f)


def filter_vote_txs(block: dict) -> list[dict]:
    result = []
    for tx in block.get("transactions", []):
        accounts = tx["transaction"]["message"]["accountKeys"]
        if VOTE_PROGRAM not in accounts:
            result.append(tx)
    return result


if __name__ == "__main__":
    block = load_block(sys.argv[1])
    all_txs = block.get("transactions", [])
    non_vote = filter_vote_txs(block)

    print(f"Slot:         {block.get('parentSlot', '?') + 1}")
    print(f"Total txs:    {len(all_txs)}")
    print(f"Vote txs:     {len(all_txs) - len(non_vote)}")
    print(f"Non-vote txs: {len(non_vote)}  ({len(non_vote) / len(all_txs):.1%})")
    print(f"Failed txs:   {sum(1 for tx in non_vote if tx['meta']['err'] is not None)}")

import hashlib
import json
from pathlib import Path


def verify_extracted_blocks(manifest_path: str, blocks_dir: str) -> None:
    with open(manifest_path) as f:
        manifest = json.load(f)

    blocks = Path(blocks_dir)
    failed = []
    verified = 0

    for entry in manifest["files"]:
        file_path = blocks / entry["file_name"]

        if not file_path.exists():
            failed.append(f"missing: {entry['file_name']}")
            continue

        h = hashlib.sha256()
        with open(file_path, "rb") as f:
            for chunk in iter(lambda: f.read(65536), b""):
                h.update(chunk)

        if h.hexdigest() != entry["sha256"]:
            failed.append(f"hash mismatch: {entry['file_name']}")
        else:
            verified += 1

    if failed:
        raise ValueError(f"Verification failed ({len(failed)} files):\n" + "\n".join(failed))

    print(f"Verified {verified} block files")
    print(f"Slot range: {manifest['start_slot']} - {manifest['end_slot']}")

-- Load Raydium dex_trades, all three programs
CREATE OR REPLACE TABLE raydium AS
SELECT
    slot,
    block_time,
    pool_address,
    token_in,
    token_out,
    amount_in_ui,
    amount_out_ui,
    programVariant,
    signer
FROM read_parquet('raydium_dex_trades_2024*.parquet')
WHERE amount_in_ui > 0
  AND programVariant IN ('amm_v4', 'clmm', 'cpmm');

-- Load Orca Whirlpool dex_trades
CREATE OR REPLACE TABLE orca AS
SELECT
    slot,
    block_time,
    pool_address,
    token_in,
    token_out,
    amount_in_ui,
    amount_out_ui,
    signer
FROM read_parquet('orca_dex_trades_2024*.parquet')
WHERE amount_in_ui > 0;

-- Implied price for each swap: units of token_out per token_in
CREATE OR REPLACE TABLE raydium_prices AS
SELECT *, amount_out_ui / amount_in_ui AS implied_price
FROM raydium;

CREATE OR REPLACE TABLE orca_prices AS
SELECT *, amount_out_ui / amount_in_ui AS implied_price
FROM orca;

-- Find slots where the same token pair had >0.55% spread across DEXes
-- 0.55% = 0.25% Raydium fee + 0.30% Orca fee (minimum to profit after fees)
SELECT
    r.slot,
    r.block_time,
    r.token_in,
    r.token_out,
    r.programVariant AS raydium_variant,
    r.implied_price  AS raydium_price,
    o.implied_price  AS orca_price,
    (r.implied_price - o.implied_price) / o.implied_price AS spread_pct,
    r.pool_address   AS raydium_pool,
    o.pool_address   AS orca_pool
FROM raydium_prices r
JOIN orca_prices o
    ON  r.slot      = o.slot
    AND r.token_in  = o.token_in
    AND r.token_out = o.token_out
WHERE ABS((r.implied_price - o.implied_price) / o.implied_price) > 0.0055
ORDER BY ABS(spread_pct) DESC;

import duckdb
from dataclasses import dataclass

FILL_DELAY_SLOTS = 2   # 1 slot detection + 1 slot bundle inclusion
RAYDIUM_FEE = 0.0025   # 0.25%
ORCA_FEE = 0.0030      # 0.30%
MIN_TRADE_USD = 100    # ignore tiny opportunities


@dataclass
class ArbOpportunity:
    slot: int
    token_in: str
    token_out: str
    raydium_price: float
    orca_price: float
    spread_pct: float
    raydium_pool: str
    orca_pool: str


@dataclass
class SimResult:
    total_opportunities: int
    profitable_after_delay: int
    avg_spread_at_signal: float
    avg_spread_at_fill: float


def simulate_arb(opportunities: list[ArbOpportunity], price_at_slot: dict) -> SimResult:
    profitable = 0
    signal_spreads = []
    fill_spreads = []

    for opp in opportunities:
        fill_slot = opp.slot + FILL_DELAY_SLOTS
        if fill_slot not in price_at_slot:
            continue

        raydium_fill = price_at_slot[fill_slot].get(opp.raydium_pool)
        orca_fill = price_at_slot[fill_slot].get(opp.orca_pool)

        if raydium_fill is None or orca_fill is None:
            continue

        fill_spread = (raydium_fill - orca_fill) / orca_fill
        net_fill_spread = fill_spread - RAYDIUM_FEE - ORCA_FEE

        signal_spreads.append(opp.spread_pct)
        fill_spreads.append(fill_spread)

        if net_fill_spread > 0:
            profitable += 1

    return SimResult(
        total_opportunities=len(opportunities),
        profitable_after_delay=profitable,
        avg_spread_at_signal=sum(signal_spreads) / len(signal_spreads) if signal_spreads else 0,
        avg_spread_at_fill=sum(fill_spreads) / len(fill_spreads) if fill_spreads else 0,
    )

import hashlib
import json
import base64
from pathlib import Path


# Anchor discriminator for the 'create' instruction
CREATE_DISCRIMINATOR = hashlib.sha256(b"global:create").digest()[:8]
PUMPFUN_PROGRAM = "6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P"


def decode_create_instruction(ix_data: bytes) -> dict | None:
    if len(ix_data) < 8:
        return None
    if ix_data[:8] != CREATE_DISCRIMINATOR:
        return None
    # Fields after discriminator: name (string), symbol (string), uri (string)
    # Then remaining bonding curve state encoded by Anchor
    return {"raw_ix_data": ix_data[8:].hex()}


def extract_pumpfun_creates(block: dict) -> list[dict]:
    slot = block.get("parentSlot", 0) + 1
    creates = []

    for tx_idx, tx in enumerate(block.get("transactions", [])):
        if tx["meta"]["err"] is not None:
            continue  # skip failed transactions

        accounts = tx["transaction"]["message"]["accountKeys"]
        if PUMPFUN_PROGRAM not in accounts:
            continue

        for ix in tx["transaction"]["message"]["instructions"]:
            program = accounts[ix["programIdIndex"]]
            if program != PUMPFUN_PROGRAM:
                continue

            data = base64.b64decode(ix["data"])
            decoded = decode_create_instruction(data)
            if decoded is None:
                continue

            creates.append({
                "slot": slot,
                "tx_index": tx_idx,
                "signature": tx["transaction"]["signatures"][0],
                "mint": accounts[1],  # mint account is second in PumpFun create
                "creator": accounts[7],  # creator wallet
                "raw_ix": decoded["raw_ix_data"],
            })

    return creates

-- Load pumpfun_events Parquet, exclude mayhem mode, reconstruct price path
CREATE OR REPLACE TABLE pf_creates AS
SELECT
    slot AS create_slot,
    mint,
    creator,
    virtual_sol_reserves,
    virtual_token_reserves,
    real_token_reserves,
    virtual_sol_reserves / virtual_token_reserves AS opening_price,
    block_time AS create_time
FROM read_parquet('pumpfun_events_creates_2024*.parquet')
WHERE is_mayhem_mode = false;

CREATE OR REPLACE TABLE pf_trades AS
SELECT
    slot,
    mint,
    is_buy,
    sol_amount,
    token_amount,
    virtual_sol_reserves,
    virtual_token_reserves,
    virtual_sol_reserves / virtual_token_reserves AS price_at_trade
FROM read_parquet('pumpfun_events_trades_2024*.parquet');

-- For each launch, compute entry and exit price at configurable slot windows
-- Entry: first trade after create. Exit: price at N slots after create.
SELECT
    c.mint,
    c.create_slot,
    c.opening_price,
    first_trade.price_at_trade  AS entry_price,
    first_trade.slot            AS entry_slot,
    exit_15.price_at_trade      AS exit_price_15slot,
    exit_30.price_at_trade      AS exit_price_30slot,
    exit_50.price_at_trade      AS exit_price_50slot,
    (exit_15.price_at_trade - first_trade.price_at_trade) / first_trade.price_at_trade AS pnl_15slot,
    (exit_30.price_at_trade - first_trade.price_at_trade) / first_trade.price_at_trade AS pnl_30slot,
    (exit_50.price_at_trade - first_trade.price_at_trade) / first_trade.price_at_trade AS pnl_50slot
FROM pf_creates c
LEFT JOIN LATERAL (
    SELECT price_at_trade, slot
    FROM pf_trades
    WHERE mint = c.mint AND slot >= c.create_slot AND is_buy = true
    ORDER BY slot ASC
    LIMIT 1
) first_trade ON true
LEFT JOIN LATERAL (
    SELECT price_at_trade
    FROM pf_trades
    WHERE mint = c.mint AND slot BETWEEN c.create_slot + 13 AND c.create_slot + 17
    ORDER BY ABS(slot - (c.create_slot + 15)) ASC
    LIMIT 1
) exit_15 ON true
LEFT JOIN LATERAL (
    SELECT price_at_trade
    FROM pf_trades
    WHERE mint = c.mint AND slot BETWEEN c.create_slot + 27 AND c.create_slot + 33
    ORDER BY ABS(slot - (c.create_slot + 30)) ASC
    LIMIT 1
) exit_30 ON true
LEFT JOIN LATERAL (
    SELECT price_at_trade
    FROM pf_trades
    WHERE mint = c.mint AND slot BETWEEN c.create_slot + 45 AND c.create_slot + 55
    ORDER BY ABS(slot - (c.create_slot + 50)) ASC
    LIMIT 1
) exit_50 ON true
WHERE first_trade.slot IS NOT NULL;

-- Assumes Kamino lending position updates and liquidation events
-- are in separate tables from the trading datasets.
-- usd_value in dex_trades provides slot-level price for collateral tokens.

CREATE OR REPLACE TABLE position_health AS
SELECT
    p.slot,
    p.block_time,
    p.position_address,
    p.owner,
    p.collateral_mint,
    p.collateral_amount_ui,
    p.debt_amount_ui,
    p.debt_mint,
    price.usd_value / p.collateral_amount_ui AS collateral_price_usd,
    debt_price.usd_value / p.debt_amount_ui   AS debt_price_usd,
    -- Health factor = (collateral_usd * liquidation_threshold) / debt_usd
    -- Liquidation threshold varies by asset; using 0.80 as example
    (p.collateral_amount_ui * (price.usd_value / p.collateral_amount_ui) * 0.80)
        / (p.debt_amount_ui * (debt_price.usd_value / p.debt_amount_ui)) AS health_factor
FROM kamino_positions p
LEFT JOIN (
    SELECT slot, usd_value
    FROM read_parquet('dex_trades_*.parquet')
    WHERE token_in = p.collateral_mint OR token_out = p.collateral_mint
) price ON price.slot = p.slot
LEFT JOIN (
    SELECT slot, usd_value
    FROM read_parquet('dex_trades_*.parquet')
    WHERE token_in = p.debt_mint OR token_out = p.debt_mint
) debt_price ON debt_price.slot = p.slot;

-- Compute lag between liquidation-eligible and liquidation-executed
SELECT
    h.position_address,
    h.slot                AS eligible_slot,
    h.health_factor,
    liq.slot              AS liquidation_slot,
    liq.slot - h.slot     AS lag_slots,
    (liq.slot - h.slot) * 0.4 AS lag_seconds_approx
FROM position_health h
JOIN kamino_liquidations liq ON liq.position_address = h.position_address
WHERE h.health_factor < 1.0
  AND liq.slot >= h.slot
  AND h.slot = (
      SELECT MIN(slot) FROM position_health ph
      WHERE ph.position_address = h.position_address
        AND ph.health_factor < 1.0
  )
ORDER BY lag_slots ASC;

-- Simulate LP position P&L for a given tick range and holding period
-- Parameters: tick_lower = -100, tick_upper = 100, pool, entry_slot, exit_slot

WITH
-- Price path from swaps through the pool
price_path AS (
    SELECT
        slot,
        amount_out_ui / amount_in_ui AS price,
        amount_in_ui                 AS volume_in
    FROM read_parquet('orca_dex_trades_*.parquet')
    WHERE pool_address = '<<your_pool>>'
      AND slot BETWEEN <<entry_slot>> AND <<exit_slot>>
      AND amount_in_ui > 0
),

-- Entry and exit price
entry_price AS (SELECT price FROM price_path ORDER BY slot ASC  LIMIT 1),
exit_price  AS (SELECT price FROM price_path ORDER BY slot DESC LIMIT 1),

-- Slots where price was within tick range
-- Tick range converts to price via: price = 1.0001^tick
in_range_slots AS (
    SELECT slot, price, volume_in
    FROM price_path
    WHERE price BETWEEN pow(1.0001, -100) AND pow(1.0001, 100)
),

-- Total volume through pool in-range (proportional fee estimate)
-- Assumes position represents p% of pool liquidity
total_in_range_volume AS (SELECT SUM(volume_in) AS total_vol FROM in_range_slots),

-- Fee income (Orca default: 0.30% per swap through in-range liquidity)
fee_income AS (
    SELECT total_vol * 0.003 AS fees_earned
    FROM total_in_range_volume
),

-- Impermanent loss from entry to exit price
-- IL = 2 * sqrt(price_ratio) / (1 + price_ratio) - 1
il_calc AS (
    SELECT
        (SELECT price FROM exit_price) / (SELECT price FROM entry_price) AS price_ratio
),
impermanent_loss AS (
    SELECT 2 * sqrt(price_ratio) / (1 + price_ratio) - 1 AS il
    FROM il_calc
)

SELECT
    (SELECT price FROM entry_price)      AS entry_price,
    (SELECT price FROM exit_price)       AS exit_price,
    (SELECT fees_earned FROM fee_income) AS fee_income,
    (SELECT il FROM impermanent_loss)    AS impermanent_loss,
    (SELECT fees_earned FROM fee_income) + (SELECT il FROM impermanent_loss) AS net_pnl,
    (SELECT COUNT(*) FROM in_range_slots) AS slots_in_range,
    (SELECT COUNT(*) FROM price_path)     AS total_slots
;

use std::collections::BTreeMap;
use std::path::PathBuf;
use std::fs;
use serde_json::Value;

#[derive(Debug, Clone)]
pub struct Block {
    pub slot: u64,
    pub block_time: Option<i64>,
    pub transactions: Vec<Value>,
}

#[derive(Debug, Clone, PartialEq)]
pub enum Side { Buy, Sell }

#[derive(Debug, Clone)]
pub struct Order {
    pub pool: String,
    pub side: Side,
    pub amount_ui: f64,
    pub signal_slot: u64,
}

pub trait BlockSource {
    fn next_block(&mut self) -> Option<Block>;
}

pub trait Strategy {
    fn on_block(&mut self, block: &Block) -> Vec<Order>;
}

/// Reads block_<slot>.json files from a local archive directory in slot order.
pub struct ArchiveSource {
    slot_index: BTreeMap<u64, PathBuf>,
    cursor: std::collections::btree_map::IntoIter<u64, PathBuf>,
}

impl ArchiveSource {
    pub fn new(archive_dir: &str, start_slot: u64, end_slot: u64) -> Self {
        let mut index = BTreeMap::new();

        let entries = fs::read_dir(archive_dir).expect("failed to read archive dir");
        for entry in entries.flatten() {
            let name = entry.file_name();
            let name_str = name.to_string_lossy();
            if let Some(slot_str) = name_str.strip_prefix("block_").and_then(|s| s.strip_suffix(".json")) {
                if let Ok(slot) = slot_str.parse::<u64>() {
                    if slot >= start_slot && slot <= end_slot {
                        index.insert(slot, entry.path());
                    }
                }
            }
        }

        let iter = index.into_iter();
        ArchiveSource { slot_index: BTreeMap::new(), cursor: iter }
    }
}

impl BlockSource for ArchiveSource {
    fn next_block(&mut self) -> Option<Block> {
        let (slot, path) = self.cursor.next()?;
        let raw = fs::read_to_string(&path).ok()?;
        let data: Value = serde_json::from_str(&raw).ok()?;

        Some(Block {
            slot,
            block_time: data["blockTime"].as_i64(),
            transactions: data["transactions"].as_array().cloned().unwrap_or_default(),
        })
    }
}

use std::collections::VecDeque;

#[derive(Debug)]
pub struct SimResult {
    pub final_pnl: f64,
    pub filled_orders: usize,
    pub final_slot: u64,
}

pub struct Simulator {
    pub fill_delay_slots: u64,
    pending: VecDeque<(u64, Order)>,  // (fill_slot, order)
}

impl Simulator {
    pub fn new(fill_delay_slots: u64) -> Self {
        Simulator { fill_delay_slots, pending: VecDeque::new() }
    }

    pub fn run(
        &mut self,
        source: &mut impl BlockSource,
        strategy: &mut impl Strategy,
        price_oracle: &impl Fn(u64, &str) -> Option<f64>,
    ) -> SimResult {
        let mut pnl: f64 = 0.0;
        let mut filled: usize = 0;
        let mut last_slot: u64 = 0;

        loop {
            let Some(block) = source.next_block() else { break };
            last_slot = block.slot;

            // Fill any pending orders whose fill_slot has arrived
            while let Some(&(fill_slot, _)) = self.pending.front() {
                if fill_slot > block.slot { break; }
                let (_, order) = self.pending.pop_front().unwrap();
                if let Some(fill_price) = price_oracle(block.slot, &order.pool) {
                    let trade_pnl = match order.side {
                        Side::Buy  => -fill_price * order.amount_ui,
                        Side::Sell =>  fill_price * order.amount_ui,
                    };
                    pnl += trade_pnl;
                    filled += 1;
                }
            }

            // Ask strategy for new orders
            let orders = strategy.on_block(&block);
            for order in orders {
                let fill_slot = block.slot + self.fill_delay_slots;
                self.pending.push_back((fill_slot, order));
            }
        }

        SimResult { final_pnl: pnl, filled_orders: filled, final_slot: last_slot }
    }
}