The problem
Solana's RPC is very good at one thing: telling you what an account looks like right now. Ask it what that same account looked like thirty days ago, thirty minutes ago, or one transaction ago, and it has nothing to say. The moment an account is overwritten, its previous state is gone from every standard node on the network.
Archival data doesn't close the gap. Block and transaction history is widely available, but transactions can't be run in reverse. You can't take today's state and subtract your way back to last Tuesday. The only path is forward replay from a known starting point, through every transaction in between, with the right program versions and runtime features active at each step. For nearly everyone, that means the question simply goes unanswered.
And they are important questions. What did the pool look like in the slot before the exploit? What state did my failed transaction actually see? Was that arbitrage really only available for one slot, or was it sitting there for thirty? Until now, answering any of them meant building your own infrastructure first.
- Run your own archival validator: weeks to set up, months to harden
- Build a custom indexer for every program you care about
- Reconstruct state from transaction history
- Hope your CPI write tracking is correct
- Maintain it through every protocol upgrade, forever
- Then build a simulation framework on top
Sometimes never.
- One JSON-RPC endpoint, authenticated with your existing SVS API key
- Every account, every program, no per-program indexing
- State served from an archive of real writes, not reconstructed
- Every write kept, including hundreds inside a single slot, each attributed to its transaction
- Historical feature sets, sysvars, and program bytecode tracked for you
- Simulation built in and anchored to the same archive
~25 milliseconds.
What Rewind is
Rewind is a hosted service built on a continuous, deduplicated archive of every account write on Solana mainnet, captured at intra-slot granularity. Not end-of-slot snapshots, not sampled state: every individual write, in order, including the intermediate states that exist for only a fraction of a slot before the next transaction overwrites them.
Two layers sit on top of that archive. Read primitives return account state, change history, and structural diffs at any position. Historical simulation executes a transaction through the SVM against the archive's state at a position you choose, with the runtime configured the way the network was configured at that moment.
Rewind is infrastructure, not a workflow tool. It doesn't generate strategies or surface insights on its own. It gives you primitives that compose, and makes hard questions about Solana's history fast to answer when you bring the hypothesis. Where a Solana RPC equivalent exists, Rewind's responses are wire-compatible with it, so the tooling you already have keeps working.
Inside the slot, not just the end of it
This is the part that matters most. A slot lasts about 200 milliseconds, and in that time a busy account, like a popular AMM pool, can be written hundreds of times. Every one of those writes is a distinct state that some transaction saw and acted on. A per-slot snapshot keeps only the last one and throws the rest away.
Rewind keeps all of them. Every write gets its own stable writeVersion and is linked to the
transaction that produced it, so intra-slot state is fully addressable:
you can read it, diff it, list it, and simulate against it.
Why it matters. End-of-slot state tells you where things ended up, not what any individual transaction encountered on the way. For exploit forensics, arbitrage analysis, and failed-transaction debugging, the state between transactions is the whole story. A simulation run against end-of-slot state is a simulation against conditions your transaction never actually faced.
Three questions Rewind was built to answer
Almost everything people do with Rewind is a variation on one of these. Each one is a single call, and each one works at intra-slot precision.
“What did this transaction actually do?”
Anchor both sides of a diff to the same signature, one positioned before and one after. You don't need to know the slot; Rewind resolves it from the signature. You get the full account state on each side plus a structural summary: lamports delta, owner change, and whether the data bytes changed. One transaction's effect on one account, isolated from everything else in that slot, in a single round trip.
import { RewindClient, transactionView } from "@solanavibestation/rewind"; const rewind = new RewindClient("https://rewind.solanavibestation.com", { apiKey: process.env.SVS_API_KEY, }); // Before/after state plus the structural diff, in one call const { value } = await transactionView(rewind, sig, pubkey); console.log(value.diff?.lamportsDelta, value.diff?.dataChanged); // value.a and value.b are the full before/after AccountInfo
“Show me everything that happened to this account.”
getAccountChanges returns one row per write across a slot range, newest first, with a
cursor for the next page. Every row carries the producing
transaction signature, a stable
content hash for deduplication, a dataChanged flag so you
can skip writes that only moved lamports, and optionally the raw bytes. Walk a pool's reserves change
by change and attribute every mutation to the transaction that caused it.
use svs_rewind::{Client, ChangesConfig}; let client = Client::new("https://rewind.solanavibestation.com")? .with_api_key(std::env::var("SVS_API_KEY")?); // The walker handles the cursor loop and pagination for you let mut w = client.walk_account_changes(pubkey, ChangesConfig::range(446_700_000, 446_800_000)); while let Some(page) = w.next_page().await? { for row in page.changes.iter().filter(|r| r.data_changed) { println!("{} {} {:?}", row.slot, row.write_version, row.txn_signature); } }
“What would this transaction have done at a different moment, or under different conditions?”
This is the question only Rewind can answer. Hand it any transaction and any position inside its coverage, and it tells you what would have happened: success or failure, the full logs, compute used, and the resulting account state. Move the position and ask again. Ten slots earlier. One write later. The instant before a competitor's transaction landed. Each answer is one call, and ~100ms away.
Would your arb have been profitable forty slots before anyone took it? Would the liquidation have cleared an hour earlier? Would a transaction that failed have succeeded if it had landed two writes sooner in the same slot? Point the simulator at the transaction's own signature and you get a faithful replay that explains why it did what it did. Point it anywhere else and you get the counterfactual.
// One transaction, replayed at each of the 40 slots before it actually landed for (let slot = landedSlot - 40; slot <= landedSlot; slot++) { const { value } = await rewind.simulateHistoricalTransaction(txBase64, { slot }); console.log(slot, value.err ? "would have failed" : "would have succeeded", value.unitsConsumed); } // Or inside a single slot: the state right after one specific write await rewind.simulateHistoricalTransaction(txBase64, { slot, writeVersion }); // Or the exact state a known transaction saw, without knowing its slot await rewind.simulateHistoricalTransaction(txBase64, { anchor: { signature: sig, position: "before" }, });
To change the conditions rather than the moment, add accountOverrides and swap in a
different oracle price, balance, or program version. More on that
below.
The primitives
Eight JSON-RPC methods on a single endpoint. Compose them however you want.
Pointing at a moment in history
Every read method and the simulator share one positioning vocabulary. Learn it once and it works everywhere. There are three ways to say when, and two of them reach inside a slot. Each returns the newest version of the account at or before the point you name.
getAccountChanges rows and are stable: each one identifies exactly one write, forever.
With an anchor, the slot is resolved from the signature, so you never have to look it up.
Every response echoes back the position of the version it actually served, as
rewindSlot and rewindWriteVersion. If that's earlier than what you asked for,
the account simply wasn't touched in between and its state carried forward. That pair doubles as a
stable cache key and as a valid pagination cursor for
getAccountChanges, so moving between point reads and history walks is seamless.
Historical simulation flagship
Reading the past is useful. Executing against it is where Rewind becomes
something new. simulateHistoricalTransaction takes a transaction (legacy, v0, or v1; signed or
unsigned) and runs it through the SVM against the archive's state at the position you choose. That position can be the end of any slot in coverage, or any point inside a slot: between two specific writes, or immediately before or after a known transaction.
The hard part of historical simulation isn't running the VM. It's reconstructing everything the VM depends on. Rewind assembles all of it for the moment you target:
Failed transactions still return their logs and compute units, which is usually the point.
What-if analysis with account overrides
Faithful replay tells you what happened. accountOverrides lets you ask what
would have happened. Supply up to 64 overrides per simulation, in two
flavors:
| Override | What it does | Example question |
|---|---|---|
| static | You supply the account yourself: lamports, owner, and data bytes. | “Would the liquidation have gone through if the oracle had read 2% lower?” |
| loadAt | Rewind loads that one account from a different position in the archive than the rest of the simulation. | “Would this exploit still work against the program version deployed after the patch?” |
That is something you cannot do on a live network, a local validator, or a forked snapshot without
substantial manual work. With loadAt it's one field in a JSON request. A separate
preStateSlot option loads account state from one slot while resolving lookup tables at
another, for the cases where those need to differ.
Hypotheticals are always labeled. Any account whose state came from an override is
listed in rewindOverriddenAccounts. If that list is non-empty, the result is hypothetical.
If it's empty, you're looking at a faithful replay. There's no way to confuse the two, which matters
when the output ends up in a post-mortem or an audit report.
Guardrails prevent incoherent setups: sysvars and lookup tables can't be statically overridden, and moving an upgradeable program without moving its program-data account to the same position is refused with an error naming both accounts.
Honest by design
Historical data is only valuable if you can trust it. An archive that silently returns a slightly wrong answer is worse than no archive, because you'll build conclusions on top of it. Rewind follows a simple rule: the archive is complete, and if we ever can't give you the right answer, we refuse and tell you why.
Why the archive stays at 100%
For an archive like this, completeness isn't a nice-to-have metric. Every read returns the newest version of an account at or before the position you ask for. If even one slot were missing, a write inside it would be invisible, and every later read of that account would quietly return the wrong answer until the account happened to be written again. One hole corrupts everything downstream of it. So we hold the archive to a simple standard: 100% of slots, no exceptions.
Capture runs on redundant ingest paths, and every slot is independently verified after it lands. If a slot is ever missed at the tip, it's flagged immediately and backfilled and re-verified shortly afterward, without anyone having to ask. A gap is a short-lived repair ticket, never a permanent feature of the data. And for the brief window before a repair completes, Rewind would rather refuse a query than answer it wrong.
Verify it yourself
One call to getRewindCoverage reports the earliest and latest slot, the missing-slot count, and the gap percentage. You never have to take our word for it.
Gaps get repaired, not tolerated
A slot missed at the tip is detected automatically and backfilled soon after. Once repaired, it's indistinguishable from any other slot, intra-slot writes included.
Refuse rather than guess
If a query touches a slot that's still mid-repair, you get a distinct error with the bounds instead of silently older data. Retry shortly, or pass tolerateGaps: true to accept the older answer knowingly.
Skipped slots understood
Leader-skipped slots produced no block on chain. They aren't gaps, don't count against coverage, and don't trigger refusals, because the at-or-before answer is already correct.
Errors you can route on
Error codes are deliberately fine-grained, so your code can tell “too new” from “too old” from “not indexed” and respond to each differently.
| Code | Meaning | What to do |
|---|---|---|
| -32014 | Position is above the archive's latest slot | Too new. Query a live RPC instead. |
| -32015 | Position is below the earliest slot your key can reach | Too old. Outside the archive or your plan's window. |
| -32016 | Anchor signature is not indexed | Check the signature, or position by slot. |
| -32017 | Filtered account class (Vote) | Not archived by design. See below. |
| -32018 | Position touches a slot that is still being repaired | Rare and temporary. Retry shortly, or opt in with tolerateGaps. |
One deliberate exclusion: Vote accounts. They're rewritten every slot and would bloat
the archive while serving almost no analytical purpose, so Rewind doesn't archive their data. Their
existence is still recorded, which means a read or simulation that touches one is
refused with a clear error naming the account, rather than silently answered with
null. Typical workloads such as DeFi swaps, arbitrage analysis, liquidations, and NFT
marketplace flows never touch them.
Who it's for
Rewind is for people who already know what they want to investigate, and have been blocked by the fact that the data didn't exist.
“What was the exact pool state when the exploit happened?”
Reconstruct any moment your protocol experienced. Reproduce an attack against historical state to confirm the vulnerability, then validate the fix against the same conditions. Test changes to LTVs, fees, and rebalance frequencies against real chain history instead of idealized models.
“Would my transaction actually have executed at the price my backtest assumed?”
Price-based backtests assume idealized execution. Real strategies hit slippage, racing, and fee dynamics that OHLCV data can't model. Rewind shows you what would have actually happened: same execution engine, same account state, same conditions as mainnet.
“Would this attack have worked at any point in the protocol's history?”
Forensic reconstruction that used to take weeks of custom infrastructure becomes hours of API calls. Verify exploits against the exact state they targeted, and test attack vectors across thousands of historical moments, with every hypothetical clearly labeled in the output.
“How much am I missing because of execution gaps?”
You know what you captured. Rewind shows you what the chain looked like at the moments you didn't. Replay a winning transaction at earlier slots to see how long the opportunity was really open, and size your infrastructure investment against a real denominator.
From our own research: replaying real, landed arbitrage transactions at earlier slots, we've found opportunities that were already profitable many slots before anyone took them. Some stayed open for 30+ slots, particularly three- and four-hop routes that most searchers skip as too complex. That kind of finding only becomes visible once you can execute against the past.
Drop-in compatible, with typed SDKs
Rewind speaks plain JSON-RPC 2.0 and uses the same authentication as every other SVS endpoint: an
Authorization header or an api_key query parameter.
getHistoricalAccountInfo and getMultipleHistoricalAccounts are strict supersets
of their Solana counterparts, so @solana/web3.js,
solana-py, and other standard SDKs deserialize the responses as ordinary
AccountInfo objects and simply ignore the extra fields. The usual encodings are
supported, including jsonParsed, base64+zstd, and dataSlice.
Node 18+ or any browser with fetch. Zero runtime dependencies.
Async on tokio. Optional zstd feature for compressed account data.
Both expose one typed method per RPC method and a typed error carrying the JSON-RPC code, plus the same helpers for the workflows that come up constantly:
Plans and access
Access is metered per API key. Your plan sets two things: how far back you can reach into the archive, and your rate limits for reads and simulations. During the beta, the Pro tier gets a rolling 30 days of coverage, intra-slot writes included.
Want more than 30 days? Tell us. Keeping every intra-slot write for every account on mainnet is a serious storage commitment, so we're scaling retention to match real demand. If enough teams need it, we'll open an Enterprise plan covering more than a year of history. If that's you, reach out on Discord or through your customer portal and tell us what you'd do with it.
Your effective window is always visible in getRewindCoverage, so there's never any
guessing about what a key can reach.
What's next
The foundation is live and ready to use today. What comes next builds upward, from single questions to questions asked at scale.
Account state archive and simulation primitives
Continuous capture of every mainnet account write, transaction-position indexing, per-slot feature sets, sysvar and lookup-table resolution at historical slots.
Read methods and historical simulation
Everything described in this post. ~25ms p50 reads, ~100ms p50 simulations.
Sweep simulation and async jobs
Run one transaction at every interval across a slot range, as a managed job with persistent state. Being validated against real workloads before release.
Trigger-driven simulation
Define a condition over chain state, find every moment it was true, and simulate a transaction at each one. Not practical without an indexed archive of account versions.
Discovery workflows
Parameterized strategy templates instantiated against historical state at every candidate moment, then filtered by profitability.
None of this order is fixed. It gets re-sorted by what beta users are actually trying to build, which is the subject of the next section.
Beta users decide what Rewind becomes
Rewind is new, and nothing quite like it has existed on Solana before. That means there's no playbook for what it should do next, and we'd rather build from what you actually need than from what we imagine you need. If you're using Rewind during the beta, you have real influence over where it goes.
We're a small team and we talk to our users directly. A request from someone running a real workload carries more weight with us than anything on our internal list. Methods, parameters, SDK helpers, retention, rate limits, the order of the roadmap above: all of it is open to change based on what beta users tell us.
- The API itselfA method that's missing, a parameter you keep wishing for, a response field that would save you a second call.
- What gets built nextSweep, trigger, and discovery workflows are ordered by our best guess. Tell us which one you'd use tomorrow and the order moves.
- Coverage and limitsHow far back you need to reach, which account classes matter to you, and what request rates your workload really requires.
- Tooling and supportAnother SDK language, a CLI, better examples, a worked guide for your use case, or simply faster answers when you're stuck.
It doesn't need to be polished. A one-line message, a screenshot of an error, a half-formed idea: send it. We read everything, and we'll tell you honestly whether it's something we can build, already have planned, or can't do and why.
Stop guessing what the chain looked like.
If your work depends on knowing what Solana looked like at a specific moment in the past, or what would have happened if you'd acted on it, Rewind was built for you. Read the docs, make your first call, and then tell us what you found and what was missing. During the beta, that feedback is what we build from.
Read the docs Join our Discord