Solana · MEV Marketplace · Closed Beta
Catscope is the lowest-latency validator-side runtime for Solana — a decentralized MEV marketplace where validators sell bandwidth and traders watch the network change before anyone else can react.
Block 287_412_198
Δ +0.42% · latency 1.7ms
The thesis
Solana settles in 400ms. Most bots find out about the state change after it's already worth less. Catscope sits inside the validator — the place where the network is born — and lets you act before the rest of the market can even see the data.
1.7ms
Median read latency
Validator-side, no proxy
0
RPC calls required
Native plugin stream
WASM
Bot runtime
Rust · Go · any WASM lang
100%
On-chain pricing
Continuous auction
Three markets. One runtime.
Catscope is not one product. It's a three-sided marketplace that turns validator infrastructure into programmable, priceable, on-chain bandwidth.
Deploy your trading bot directly inside a validator. No co-location. No middleware. Just first-visibility execution on the same machine that proposes blocks.
Skip the RPC tax. Subscribe to a live graph of decoded Solana accounts — nodes, edges, every dependency — straight from a validator's geyser plugin.
Route transactions straight into the validator that's about to produce the next block. Skip the mempool. Skip the public RPC roulette. Land first or don't land at all.
How it works
CatGeyser is the state management layer — a specialized Solana geyser plugin that filters and streams decoded account data through shared memory. CatBot is the runtime that hosts your WASM strategy inside the validator and reacts the millisecond state changes.
The plugin parses raw account writes and slot changes inside the validator, applies your filters, and streams only what you asked for — no flooding, no dropped messages.
Each validator's available guest capacity is listed on-chain. Traders bid for access. The auction clears continuously, no fixed tiers.
Compile your bot to wasm32-wasip2 (Rust, Go, anything) and CatBot installs it in a guest slot. State arrives via shared memory — zero network hops.
Your evaluate() runs on the same machine that proposes the next block. Decision and submission happen before public mempool traffic can react.
Built for developers
The surface area is small on purpose. Subscribe to accounts in on_load. React in evaluate(). Submit a transaction. Catscope handles the validator, the optimizer connection, and the marketplace. You write the strategy.
pub(crate) fn on_load(&mut self) {
let g = self.o_graph.take().unwrap();
// Subscribe to a pool account
let pool = account_id_from_pubkey(&POOL_PUBKEY);
let _sub = g.subscribe(pool, 0, 0).unwrap();
self.o_graph.replace(g);
}
pub(crate) fn evaluate(&mut self) {
if self.state.spread > self.cfg.min_spread {
let ix = build_arb_ix(&self.state);
self.wallet.append_ix(ix, 0);
if let Some((sig, tx)) = self.wallet.assemble() {
transactionprocessor::send(sig.as_ref(), tx).ok();
}
}
}Two sides. Same incentive.
For tradersYou don't lose alpha to bad strategy. You lose it to latency, indexer lag, and public RPC contention. Catscope removes all three.
For validatorsYour bandwidth is an asset. Catscope turns it into a continuously priced revenue stream — Bot fees, Read fees, Write priority fees, and a reputation score that compounds.
What you'll build
Spot a mispricing the moment a pool updates. Atomic-bundle the rebalance before the next block.
Watch borrow positions in real-time. Be first into the liquidation when collateral slips.
Quote tighter spreads when you see depth change ahead of your competitors.
Catch hostile activity targeting your own flow and route around it.
Build the next CLOB without paying for a third-party indexer.
Power dashboards, trading terminals, and risk engines from a single stream.
On-chain auction
Validator capacity is auctioned continuously on-chain. Demand high? Price moves up — and validators earn more. Demand low? Price drops. No fixed tiers. No hidden fees. No backroom contracts.
Live now
Recurring fees scale with searcher trust. Honest behavior = compounding revenue. Bad behavior = the market routes around you.
Bot
rev share
Read
per-byte
Write
priority
Coming soon
In developmentA real-time view into Catscope's marketplace — validator activity, auction prices, bot performance, and decoded account state. All the signal, none of the noise.
Final call
Catscope is in closed beta with a select cohort of validators and trading teams. Pull the SDK, run the quickstart, ship a bot — and trade first.