Oracle Reset Replay: When a Pending Signed Update Returns
A reset can clear stored state. It cannot revoke a transaction already signed and waiting to land.
Research at a glance
This anonymized EVM case study explains how an oracle reset can erase the timestamp that rejects old updates while a publisher's already-signed transaction remains pending. If it lands before its original quote expires, the old price and compatible book data may become usable again. The article distinguishes this conditional replay path from a signature forgery and explains what a local proof of concept does—and does not—show.
- Research type
- Private EVM audit field guide
- Scope
- Solidity · EVM · Oracle security · Transaction replay
- Key lesson
- A reset clears contract state; it does not revoke pending signed transactions. Use a per-oracle generation to invalidate pre-reset publications, and test real transaction ordering around recovery.
Evidence and context: Solidity and EVM security review experience
An oracle reset is supposed to give a protocol a clean starting point. But deleting stored data does not erase a transaction that has already been signed and is still waiting in a mempool.
In an anonymized EVM audit, this distinction exposed a recovery risk: a reset cleared the timestamp that rejected old updates, while a previously signed publisher transaction remained valid. If that transaction landed soon after the reset, the contract could treat its old price as usable again.
This is a generalized case study. It omits the protocol, chain, code identifiers, and operational details. The lesson applies to any contract that combines signed updates, freshness checks, and an administrative reset.
The short version
A protocol can revoke data already stored on-chain. It cannot reach into the transaction pool and revoke a publisher’s signed transaction. If reset erases the only record that an update is old, that pending transaction may become acceptable again.
This is not a forged signature. The publisher really signed the transaction. An attacker with access to the raw pending transaction can rebroadcast it and try to get it included after reset; the attacker cannot guarantee the network’s ordering.
How the reset replay works
- A publisher signs an update. It contains a price and, where needed, compatible order-book data. The transaction has not yet been included.
- Newer information reaches the contract, or the operator decides to reset the oracle. The old transaction would normally fail because its timestamp is older than the stored one.
- The owner resets the oracle. The contract deletes the stored quote and book, including the timestamp used to reject older publications.
- The still-pending transaction lands. Its signature is still valid and its nonce is still unused. With the stored timestamp now zero, its positive timestamp passes the “newer than stored” check.
- The protocol evaluates the restored data. Some systems stamp the current inclusion block when an update lands. The old quote can then pass block-age checks if its original timestamp is still within the wall-clock freshness limit and its order levels have not expired.
For example, imagine a publisher signed a price of $100. The outside market moves to $105, and an operator resets the oracle to keep the old data from being used. If the pending $100 update lands after reset and remains within the protocol’s freshness window, a trader may be able to buy at $100 and sell near $105 elsewhere. The price movement is only an illustration; it is not a claim about a live market.
What the local test proved—and what it did not
A focused local Foundry test showed that a publication rejected as stale before reset could be accepted after reset, restore quote and book data, and support a swap under deliberately different test prices. A separate local Anvil check was used to exercise actual signed transactions around reset. Together, these demonstrate the state-transition path and the possible economic consequence if a favorable price gap exists.
They do not show that a live market had such a gap, that pending updates commonly survive resets, or that a loss occurred in production. The Foundry test models the recovered publisher address; the Anvil check demonstrates local transaction ordering, not a production-market loss.
The transaction must still be valid: its account nonce cannot already be consumed, its fee must remain acceptable, the quote must remain inside the normal time limit, and the book must remain executable. A mined transaction cannot be replayed with the same nonce.
Why a reset is not revocation
A reset changes contract storage. It does not cancel signed transactions, invalidate publisher authorization, or change the publisher’s account nonce. If the contract uses the stored timestamp as its only ordering checkpoint, deleting that timestamp also deletes its memory of which updates came before the reset.
Freshness is usually checked in more than one way. The original update time can limit age in seconds; the inclusion block can limit age in blocks; order-level time-in-force can expire book entries. Those checks still matter, but they do not necessarily prevent a recently signed old update from getting a new inclusion-block stamp after reset.
How protocol teams can prevent it
Use an on-chain generation or epoch. Store a generation for each oracle and increment it on reset. Require every signed publication to include the generation it was created for, and reject updates from earlier generations. A reset then invalidates pending updates even if their transaction signatures remain valid.
A reset-time minimum timestamp is a smaller alternative, but it needs a future-time bound too: otherwise an old signed update carrying a far-future timestamp could pass the floor. A generation is clearer because it directly represents whether a publication belongs to the current oracle lifecycle.
- Define what reset promises: “clear current data” or “invalidate all data authorized before this reset.”
- Test a pending update before and after reset, including quote-only, book-only, and combined update paths.
- Use a local chain with automining disabled to test real signed transactions and block ordering—not only a sender impersonation in a unit test.
- Check the normal freshness and order-expiry gates after replay; test both a valid recent quote and one that should be stale.
- Make recovery runbooks invalidate or replace pending publications, while treating on-chain generation checks as the security boundary.
Questions founders should ask
- Can a signed update remain valid after an oracle reset?
- Does reset advance a nonce, epoch, or generation that publications must match?
- Can a landing-block stamp make an old quote look newly included?
- Are quote time, block age, and order-level expiry checked independently?
- Does the test suite replay the exact signed transaction around reset, or only call as the signer?
FAQ: Oracle resets and pending transactions
Does an oracle reset cancel a pending signed transaction?
No. A reset changes the contract’s stored state. It does not cancel a publisher transaction that is already signed and still has an unused account nonce.
Can someone rebroadcast it without the publisher’s private key?
If they have the raw signed transaction, they can rebroadcast that exact transaction. They cannot edit its contents or guarantee when the network includes it. This is rebroadcasting an unmined transaction, not forging a signature or replaying a transaction that has already used its nonce.
What is the strongest on-chain defense?
Use a per-oracle generation counter. Increment it on reset, include the current generation in each publication, and reject updates from older generations.
The takeaway
A reset can clear state, but it cannot revoke a signed transaction waiting to land. If recovery must invalidate old publications, enforce a per-oracle generation on-chain—and test the pending-transaction ordering that real networks allow.