Replay the last 24 hours of Solana mainnet through your existing Yellowstone gRPC client. Same protocol, same ordering, 100μs precision. Pay per replay.
Devnet has no MEV, no congestion, no real adversaries. Custom simulators drift from validator behavior the moment a new program hits a new edge case.
Sillage keeps 24 hours of mainnet — every account write, every transaction, every block — and streams it back through the same protocol your live bot already speaks. The chain that happened, on demand, at the timing it happened.
Same Yellowstone gRPC, same SubscribeRequest, same filters. Sillage speaks the protocol as a server.
The stream begins there and replays at wall-clock speed, intra-slot ordering preserved to 100 microseconds.
Pay per replay. Re-run yesterday's window as many times as your tuning loop needs.
Only the endpoint and starting slot change. Your SubscribeRequest, filters, and message handling are untouched.
let mut client = GeyserGrpcClient::build_from_shared( "https://replay.sillage.sh", )? .x_token(Some(api_key))? .connect() .await?; let req = SubscribeRequest { // any slot within the last 24 hours from_slot: Some(312_847_201), transactions: hashmap! { "swaps".into() => SubscribeRequestFilterTransactions { account_include: vec![JUPITER_V6.into()], ..Default::default() }, }, ..Default::default() }; let (_, mut stream) = client.subscribe_with_request(Some(req)).await?; while let Some(msg) = stream.next().await { handle(msg?); }
Join the waitlist. First 100 members unlock a free 24h replay; everyone else gets an endpoint as cohorts open.
No. Sillage speaks the Yellowstone gRPC protocol as a server. Point your existing client at the new endpoint and pass a starting slot — your SubscribeRequest, filters, and message handling work as-is.
Every message carries the timestamp it was received during live capture, preserved to 100 microseconds. Intra-slot ordering, propagation gaps, and the texture of real network time all replay as they happened.
From the current chain tip backwards, rolling continuously. The workloads we serve — backtesting, indexing backfill, reorg checks — all live in this window. Beyond 24h, replay stops paying for itself.
An RPC gives you on-demand queries; it doesn't give you a replayable, time-ordered stream of every account write that happened yesterday. Sillage does, through the protocol your bot is already wired for.
Helius, Triton, and QuickNode all stream the chain forward beautifully. None of them ship 24 hours of history through the same protocol, billed per replay. That's the inverse Sillage was built for.