diff --git a/.cargo/config.toml b/.cargo/config.toml
new file mode 100644
index 000000000..4c056702c
--- /dev/null
+++ b/.cargo/config.toml
@@ -0,0 +1,5 @@
+# A `cargo update` picks, for each dependency, the newest release whose declared `rust-version` the
+# workspace's own (1.94) builds, so the lock stays on the declared minimum toolchain; CI's msrv
+# job checks it there. Resolver "2" would otherwise pick the newest release whatever it declares.
+[resolver]
+incompatible-rust-versions = "fallback"
diff --git a/.cargo/mutants-infra.toml b/.cargo/mutants-infra.toml
new file mode 100644
index 000000000..66772a845
--- /dev/null
+++ b/.cargo/mutants-infra.toml
@@ -0,0 +1,22 @@
+# cargo-mutants configuration for the test gates' own infrastructure.
+#
+# The canonical run (.cargo/mutants.toml) mutates mega-evm production code and excludes test
+# helpers as noise. By that rule the scenario runner (its transaction conversion and its
+# execute/commit loop) is helper code, but it is executable logic the benches and later tests rest
+# on. This config mutates exactly that; the production run keeps its exclusions unchanged.
+#
+# Selected by `scripts/mutation_test.sh infra`, which passes the file globs. See mutants/README.md.
+
+test_tool = "nextest"
+# mega-evm's tests cover the scenario runner.
+test_package = ["mega-evm"]
+
+# Same pinned feature set as the production run, so the two generate comparable mutants.
+additional_cargo_args = ["--all-features"]
+
+# No `**/test_utils/**` exclusion here: the scenario runner living under it is the subject.
+exclude_globs = ["**/generated/**"]
+
+minimum_test_timeout = 120
+timeout_multiplier = 3.0
+copy_target = true
diff --git a/.cargo/mutants.toml b/.cargo/mutants.toml
index eb9f37b75..4c354b6d9 100644
--- a/.cargo/mutants.toml
+++ b/.cargo/mutants.toml
@@ -4,8 +4,15 @@
# (scripts/mutation_test.sh + scripts/mutation_gate.py) layers diff-scoping,
# suppression metadata, and PR gating on top of it. See mutants/README.md.
#
-# Scope: only `mega-evm` is mutated. `mega-system-contracts` produces 0 mutants
-# (its src/ is generated bytecode artifacts), so it is intentionally absent.
+# Scope: only `mega-evm` production code is mutated. `mega-system-contracts`
+# produces 0 mutants (its src/ is generated bytecode artifacts), so it is
+# intentionally absent.
+#
+# There is a second scope, .cargo/mutants-infra.toml (`scripts/mutation_test.sh
+# infra`): the code that implements the test gates themselves, which the
+# `**/test_utils/**` exclusion below and the single `test_package` would
+# otherwise leave unmutated. The two scopes are disjoint and are gated
+# separately; this one keeps its exclusions.
# Run tests with nextest (the project's standard runner) and restrict the test
# command to the mutated package for speed.
@@ -27,8 +34,11 @@ exclude_globs = [
]
# Give slow EVM-execution tests headroom before a mutant is ruled a timeout
-# (a timeout is treated as "could not decide", not as a survivor).
-minimum_test_timeout = 120
+# (a timeout is treated as "could not decide", not as a survivor). The floor
+# covers CI, where mutants build and test in parallel on one runner: a mutant
+# caught only by a test late in the order can take three times the unmutated
+# baseline to reach it.
+minimum_test_timeout = 300
timeout_multiplier = 3.0
# Seed each scratch build directory from ./target so mutant builds reuse the
diff --git a/.claude/skills/satin-review/SKILL.md b/.claude/skills/satin-review/SKILL.md
new file mode 100644
index 000000000..0795c99af
--- /dev/null
+++ b/.claude/skills/satin-review/SKILL.md
@@ -0,0 +1,475 @@
+---
+name: satin-review
+description: Guide for reviewing the Satin engine pull request (#386) in megaeth-labs/mega-evm, which holds the whole engine now that the stacked pull requests and #407 have merged into it. Use when reviewing #386 or the Satin engine, or when the user says "review satin". Gives the scope and the review range, the design changes #407 and the commits after it made to what the stacked pull requests describe, the module map with the invariants to check, the reading order, how to rate a finding, the revert-or-halt rule with its deliberate exceptions, and the decisions already made. Temporary: removed before the Satin pull request merges.
+---
+
+# Reviewing the Satin engine (pull request #386)
+
+This guide is temporary.
+It is deleted before the Satin pull request merges, so nothing else may link to it.
+It is a map: where each part of the engine lives, what to check there, what changed after the stacked pull requests were described, and what is already decided.
+Implementation detail lives in [`AGENTS.md`](../../../AGENTS.md) and the specification in [`docs/spec/upgrades/satin.md`](../../../docs/spec/upgrades/satin.md); this guide links them, and restates a rule only to say what changed.
+[`REVIEW.md`](../../../REVIEW.md) is the repository's own review rubric; its consensus-critical list overlaps the checks below.
+The guide describes the code at `cz/feat/satin-w2` with #407 merged into it and the commits after it.
+
+## What is under review
+
+- The Satin engine, in pull request #386 (`cz/feat/satin-w2`), judged at its final state.
+ The stacked pull requests #387, #388, #390, #399 and #400 (with #404, merged into #400's branch) merged into it, and then #407 (`cz/feat/satin-w9`); each description explains its part as it was merged, and a later part may have changed an earlier one.
+ The commits after #407 on `cz/feat/satin-w2` are part of this pull request and have no description of their own.
+ "Design changes a reviewer must know" below lists what #407 and those commits changed, a change those commits made marked as such.
+- The review range is the pull request's own diff.
+ Its base, `cz/feat/satin-review-base`, is `satin` before the Satin skeleton: `a8f8c7c9`, the CI-only commit before it.
+ So GitHub's "Files changed" holds the skeleton (#385) and every later series: the whole engine.
+ The local equivalent is `git diff a8f8c7c9...
`, `` being the head of #386.
+ Most of its deletions are the legacy engine, its tests and its tools (184 files): skim them, or hide them with `--diff-filter=d`.
+- #386 targets the review base only while it is reviewed.
+ It is retargeted to `satin` before it merges, and it must never be merged into the review base.
+- Judge the final code.
+ A defect an earlier commit introduced and a later one fixed is not a defect; history only explains why something is as it is.
+ A test deleted or parked in an intermediate commit is not a finding either: test completeness is judged on the whole.
+- Satin is the first spec of a line, so keep the extension points a line needs (spec-keyed constants, a spec argument); a later fork that first needs configuration parameters adds a mechanism for them then.
+ Satin is a new spec: simpler semantics win over parity with the legacy engine.
+- Out of scope: the legacy engine (`main`, frozen), which runs every block before Satin activates.
+ Satin never executes or decodes legacy-era data, so "Satin cannot handle legacy data" is not a defect, and code kept only for that purpose is dead code.
+- Fork code: the `megaeth-labs/revm` fork at `fd230a3427d1b96c88e0b581bab8a7763c8ec298` and the `megaeth-labs/op-revm` fork at `2ecb7dceed1c458a2b59ca4d8993a073968cb111`, which the patch blocks pin by `rev`, are pinned dependencies with their own review: megaeth-labs/revm#76, stacked on megaeth-labs/revm#75, and megaeth-labs/op-revm#8.
+ Their diff is not part of this pull request.
+ A finding about a fork function is about how mega-evm uses it, unless it shows the fork breaking its own documented default behaviour.
+ The fork functions the engine relies on are listed in [`AGENTS.md`, "Dependencies on the forks"](../../../AGENTS.md#dependencies-on-the-forks).
+- Where code belongs: upstream revm first, then the fork, then mega-evm.
+ The fork is only for data from the middle of revm's own flow that mega-evm cannot reach from outside; what can be done at a boundary mega-evm owns (frame start or end, the Host, the handler, the inspect path) belongs in mega-evm.
+ For each mechanism, ask whether it sits in the cheapest layer.
+- The OP base may move (Karst to a later OP fork) before launch; a finding that depends on Karst specifics should say so.
+
+## What is still moving
+
+Nothing.
+#407 has merged into this branch, and with it everything its description listed as still to be added: inspectors on revm's own inspected lifecycle, a rewritten result taken as given, one fixed gas budget for the pre-block calls, the cleanups, and the KV-update and state-growth limits with their 98/100 frame shares and the destruction table's give-backs.
+It also counts a creator's nonce record when the creation returns, which its description did not list.
+The commits after it on this branch count a frame start's records from what revm did; they are part of this pull request, and the design changes below mark what they changed.
+Every module is at its final state for this review: there is no longer a table of stable and changing modules, nor a rule to hold back findings in a changing one.
+What follows this pull request changes no rule.
+The fork pins move from the reviewed commits to the merged commits of megaeth-labs/revm#76 and megaeth-labs/op-revm#8, and to release tags once the line is final.
+Performance work is left for later: the optimisations #407 recorded are made together once the structural work is done, measured against CodSpeed's report.
+
+## Design changes a reviewer must know
+
+The stacked pull requests' descriptions predate #407 and the commits after it on this branch, which changed parts of what they describe.
+A change made after #407 merged is marked as such: it is not in #407's diff.
+Each change is stated here in plain words with its reason; the specification has the rule and `AGENTS.md` the mechanism.
+
+### Where the engine meets revm
+
+- **Inspectors run on revm's own inspected lifecycle, and the engine has no inspector-specific code.**
+ The engine's inspected copies of the frame lifecycle, its step guard and `src/evm/inspector.rs` are gone: every per-frame mechanism sits in the frame start, run result and return (`frame_init`, `frame_run_result`, `frame_return_result`) that revm's plain and inspected loops share.
+ A result an inspector rewrites is settled by the caller as revm settles it, with no correction of the engine's, and an answer it gives in place of a frame never reaches the engine's frame start, so the depth guard, the interceptors and gas detention see none of it.
+ Block execution admits any inspector.
+ Why: a second copy of the lifecycle had to be kept in step with revm's and made an inspected run differ from a plain one, and which inspectors run on block production is the node's choice.
+- **The fork's loop hooks.**
+ revm's frame run returns an action set on a frame before it runs, without running an instruction or calling the inspector's `step`, and its inspected frame start hands a frame built with one to no `initialize_interp`: a `keylessDeploy` call's creation and answer, and the stop of a caller a child left over a limit, come back through revm's own run.
+ The run-result hook (`EvmTr::frame_run_result`) is called once a frame's run returns, before the inspector's `call_end`, `create_end` and `frame_end` and before `frame_return_result`; gas detention turns a crossing into the stop there, so inspectors and tracers see the stop the caller gets.
+ Why: both are points in the middle of revm's own loop that mega-evm cannot reach from outside, which is what the fork is for, and with them the engine has no frame run of its own.
+- **Writes and frame starts are metered in the fork's instruction hooks.**
+ `SSTORE`, `LOG0`–`LOG4` and `SELFDESTRUCT` call `write_completed` once the write is in the journal and every charge the opcode makes is made.
+ The four calls and the two creations call `frame_starting` once the forward is taken: the caller is charged the history of the start's records out of what it kept, and the frame's own part is declared on the start (`FrameStart::charge`) for the fork to refund when the frame fails.
+ Why: a write the opcode's own failure takes back is never counted, and the engine no longer rebuilds revm's state from outside with instruction wrappers.
+
+### What is counted
+
+- **Data size, KV updates and state growth are pools on revm's gas tracker.**
+ Each is a pool on every frame's `GasTracker`, which the fork forwards to a child at a start and settles on the child's return as it settles the EIP-8037 reservoir; the transaction's limits are held beside the pools, on what the transaction keeps.
+ The engine's per-frame record lanes, its journal wrapper and its ledger are gone, and the context's journal is revm's own.
+ Why: a frame's budget then fails and succeeds with the frame's own gas, by revm's settlement, instead of a second account kept beside the journal.
+- **Write records follow the net change.**
+ An account's record exists while its nonce, balance or code differs from what the transaction loaded, and a slot's while its value differs from its original.
+ The per-frame deduplication is gone, a `SELFDESTRUCT` records the account it clears as well as its beneficiary, and a creation is charged exactly the records it makes.
+ Why: the record measures the state the transaction keeps, by revm's own notion of a change; the per-frame count over-counted, and charged history gas for writes that leave nothing.
+- **A frame start is held to the limits once revm decided it, on what it kept.**
+ Made after #407 merged: #407 already held a start once revm decided it — a built frame stopped before its first instruction, an answer stopped on its untouched forward, a collision not stopped for its start — but to records it predicted from the journal before revm decided, which it held the two answers below to as well; the commits after it count what revm did, and hold a failed answer to no records limit and a detention-priced answer to its price alone.
+ Its accounts on the frame are read before revm decides the start and again once it did, and what changed between — each account's record, an account that was empty and is not, the transfer log revm journaled — is counted on the started frame's pools; nothing is predicted.
+ A frame revm built returns the stop before its first instruction, and a success revm gave without building a frame gives way to the stop on the untouched forward, its value move taken back.
+ An answer that failed kept nothing, revm having taken back what its start moved, and is held to nothing: a value call to a precompile that fails at a budget boundary ends as the precompile's failure, which burns its forward, not as a limit's stop.
+ A precompile gas detention answers from its price before revm runs it moved nothing and is held to the price alone: its stop is kind 2, whatever records its value transfer would have made.
+ A creation onto an occupied address fails on the collision, and is not stopped for what its start would count.
+ Why: the limit judges what the journal kept, by the same rule at every start, instead of a prediction of revm's start held to the journal only in debug builds and checked hypothetically for the two answers that leave nothing to read; the opcode's history charge is still priced from the journal's state before revm decides, which on the plain path is exact because the opcode makes revm's refusal checks first, and the start's credit settles a price that differs from what revm made.
+- **A creator's nonce record is counted on the creator when the creation returns with the nonce bumped.**
+ The creation's budget is the share taken at the opcode, before that record, which is Rex6's order.
+ The record is held to the creator's budget, not the creation's, and survives the creation's failure; a keyless signer's is counted on the call at its settlement, and the keyless creation's share is of the call's whole pools, which the call draws nothing from before it.
+ The frame-start hook only prices: it charges the start's history and counts nothing (`hold_creator` in `src/evm/execution.rs` counts the record).
+ A start an inspector rewrites after its opcode is not charged again: what the opcode charged stands, its declared part coming back only as for any start whose frame keeps nothing, and its records are those revm then made; the specification says nothing of inspectors, and `AGENTS.md` states this.
+ Why: the bump is a fact only once revm made it, and the creator's pools are in reach again only at the return, so nothing is counted before revm decides and nothing has to be given back.
+- **A frame a failure below it left over the transaction's limit is stopped as it resumes.**
+ A failed frame's counts go back to what the frames kept when it started, a record of theirs it took back included, while an Oracle hint it admitted stays counted; a hint sent into the room such a take-back freed leaves the transaction over its data-size limit, and the frame it returns into returns the transaction's stop before its next instruction (`AdditionalLimit::hold_caller`), whether the frame below reverted, halted or was itself stopped.
+ Why: without it a caller that catches the failure could end the transaction above its limit.
+- **KV updates and state growth are limited again**, per transaction (`TX_KV_UPDATE_LIMIT` = 500,000 write records, `TX_STATE_GROWTH_LIMIT` = 1,000 new accounts and slots), per frame (98/100 of what the parent has left) and per block (`BLOCK_KV_UPDATE_LIMIT` = 500,000, `BLOCK_STATE_GROWTH_LIMIT` = 1,000, packing budgets as the block's data size is).
+ The KV count is the write-record count.
+ State growth rises by one where EIP-8037 charges the state gas of one new account or slot, and for the caller a failed deposit creates, which pays no state gas; it falls when a slot whose original is zero is written back to zero; a frame's net is signed, and a negative net never enlarges a child's budget.
+ An EIP-7702 list that would cross either limit is skipped whole, and the transaction's own frame is stopped before it runs.
+ Why: these are Rex6's limits, and gas does not stand in for the count: 1,000 fresh slots cost 97,920,000 state gas, which a gas limit can cover; at Satin's constants data size binds before the KV count, and the KV check is still made.
+- **The destruction table.**
+ The first effective `SELFDESTRUCT` of an account created in the same transaction gives back what the transaction made of it: each part absent at the transaction's start and present before the destruction — the account leaf, its deployed code, each slot written non-zero — is refilled at the state gas it was charged, to the destroying frame; the leaf and each such slot lower state growth by one and have their write records and those records' history taken back, and the code's data size and history gas are taken back.
+ A slot's value at the start is its original in the transaction, so a slot of the created account first accessed after the creation is zero there whatever the state held; a leaf is absent when no account stood at the address: the database answered none (`None`, not an empty account), or an earlier transaction on the same journal destroyed it (`Accounts::was_absent_at_start` in `src/limit/record.rs`).
+ A part present at the start is an ordinary deletion; a failure of the destroying frame, or of a frame that contains it, discards all of it.
+ From the mark the account adds no further state growth or record, and every state charge on it is priced at nothing (`Host::state_gas_price`), so a later `SSTORE` or a deposit of its constructor's code is never charged state gas rather than charged and refilled; the table's own give-back prices outside that rule (`MegaContext::priced_state_gas`).
+ The neutral configuration counts the table and prices state gas as the fixture's fork does, which gives none back, so equivalence mode's transactions that create and destroy an account report other usage than before the table, and nothing else differs.
+ The op-revm baseline pins the divergence (`test_a_creation_that_destroys_itself_diverges_from_op_revm`).
+ Why: a part the transaction made does not remain for a node to store, so the count and the charge stay aligned; EIP-8037 refills nothing for this destruction and Rex6 refunded no storage gas, so this departs from both on purpose.
+- **A fact about a transaction's start is read off that transaction's journal.**
+ revm's account flags of a database load (`LoadedAsNotExisting`), of a touch and of a destruction are set once per journal and outlive the transaction that set them when a journal runs several transactions without finalizing; the engine reads such a fact with what the journal records of the running transaction — the original info, the transaction id of what it loaded, its entries (`JournalEntry::AccountDestroyed`'s status, `AccountTouched`) and the local created and destroyed flags — and never off such a flag alone.
+ So what the engine decides on such a journal follows what revm charges there, as it does on a fresh one: the destruction table's leaf, the keyless empty-deposit rule and its answer (`Accounts::is_destroyed`), and the authorities an EIP-7702 list created (`applied_authorities` in `src/evm/execution.rs`, which counts one where revm charged it a new account).
+ Why: a node's block executor finalizes each transaction, but `transact_one` on the public API does not, and a count must not part from its charge on either path.
+
+### Gas
+
+- **The 98/100 forwards.**
+ A call or a creation forwards at most `remaining − remaining × 2 / 100` of the caller's regular gas, in place of EIP-150's 63/64 (the schedule's `call_stipend_reduction`, 50), and a value call's 2,300 stipend is added after the cap.
+ Every child receives `remaining − remaining × 2 / 100` of the caller's reservoir, whatever regular gas the call asks for; the transaction's own frame and a system call's outermost frame take the whole reservoir, and a keyless deployment's creation forwards `min(gasLimitOverride, remaining)` of regular gas with the reservoir share.
+ The three pools give a child `remaining × 98 / 100`, rounded down, so the two formulas differ at some values.
+ Why: the regular forward is Rex6's, and the reservoir share keeps a caller's own work within reach of what it calls, since state and history gas draw the reservoir first; EIP-8037 passes the reservoir whole, which would let a callee spend all of it.
+- **The history allowance replaces the storage-gas stipend.**
+ A value `CALL` or `CALLCODE` below the transaction's own frame gives the frame it starts 160 bytes of history (`HISTORY_ALLOWANCE_BYTES`, 14,080 gas at the cost per history byte, the schedule's `call_history_allowance`), on which only a log's history charge draws.
+ It never enters the frame's gas and is on no ledger.
+ Why: a `receive()` reached through Solidity's `transfer()` can still emit one event, and an allowance that is not gas leaves nothing to burn on return.
+- **One fixed gas budget for the pre-block calls.**
+ Each runs on `PRE_BLOCK_CALL_GAS_LIMIT` = 31,566,720, whatever the block's gas limit: 30,000,000 of regular gas and a reservoir of sixteen fresh slots at the minimum bucket.
+ Why: a pre-block call does not draw on the block's gas; Rex6's `max(block gas limit, 30,000,000)` was widened for storage gas a crowded bucket multiplied, which a system call no longer pays; a pre-block call on MegaETH's chains writes at most six fresh slots, and none of the three contracts reads `GAS`.
+
+### Gas detention
+
+- **Compute counts the work run on a value call's stipend, and never what a halting frame burns.**
+ The stipend is not forwarded gas, so what a callee runs on it is compute, and what it leaves of it does not lower compute when it comes back.
+ What a halting frame burned is read off the fork's failed-charge record and is not compute, so no halt takes a detained transaction past its limit.
+ Why: the old figure let a callee spend the stipend uncounted after a read, and counting the gas a halting frame had left overshot the limit.
+- **A value call's own charges come first.**
+ Its static 100, its memory, the 11,300 value transfer and a cold access are decided as any opcode's charges are, and one that crosses the limit stops the calling frame before anything moves, whether or not the caller can fund the value; only then is a precompile decided from its price.
+ Why: an opcode's own charges are held where they are made, and the outcome must not depend on whether the value could be funded; the specification now says so where it states the precompile exception.
+- **The volatile-data rules.**
+ `BLOBHASH` is not volatile: it reads the transaction's own blob hashes.
+ `SLOTNUM` is a read of the block environment, and its refusal carries access type 12, which the contract's enum does not declare, so a handler decodes the argument as a `uint8`.
+ A call to the EIP-2935 history contract is a read of the block environment, through the `NUMBER` its `get` path executes before it loads the slot; an `SLOAD` of the storage the EIP-2935 and EIP-4788 pre-block calls wrote is state the block starts with, and is no read.
+ A `CREATE` or `CREATE2` is neither marked nor refused for loading its creator or created address, the block beneficiary included.
+ Why: volatile data is data the block, the sequencer or the oracle changes under the transaction; the blob hashes are the transaction's own, the history contract's answer depends on the block number it reads, the pre-block storage is fixed before the first transaction, and a creation's loads are the creation opcode's own checks under EIP-8037, as a value call's check of its caller's balance is.
+
+### The stop and the configuration
+
+- **Limit stops are revert-class in four dimensions, in a fixed order.**
+ A crossing of data size (kind 0), KV updates (kind 1), state growth (kind 3) or gas detention's compute limit (kind 2) reverts the crossing frame with `MegaLimitExceeded(kind, limit)`, and its caller may catch it.
+ An operation that crosses several counted dimensions at one site stops on the first of data size, KV updates, state growth; compute is decided at the regular charge, before the write is counted.
+ Inside a dimension the frame budget is tested first, and the stop names the budget whenever the budget is crossed, the transaction limit only when it is not.
+ Why: the order across dimensions and the discriminants are Rex6's, so a Rex6 decoder reads the stop, and a frame that crosses its budget is told the budget it crossed.
+- **Limits files of the first shape still run.**
+ A limits file written before the KV-update and state-growth limits returned, such as one given to `mega-evme --override.limits`, reads with the default spec's values for the four newer fields; every field that shape had stays required, and an unknown field is refused.
+ Why: a tool's existing files keep working; consensus never reads such a file.
+- **Smaller changes of the node surface.**
+ A Satin key given twice in a genesis `config` object is read as its last copy by every reader, because a node and the reference CLI parse the file into a JSON value that keeps only the last copy.
+ `satinTime` is also read from `{"$serde_json::private::Number": ""}`, decimal digits alone, the form `serde_json` hands a number over in with `arbitrary_precision` on.
+ A witness replay's exports must be a subset of the building node's and may be a proper one, because the building node's also hold what candidates it executed and dropped asked for.
+ Satin's configuration fixes off the fork's switch back to revm 40.0.3's journal semantics, which exists for the legacy engine.
+ The handler splits a system call's gas itself, at most `SYSTEM_CALL_REGULAR_GAS_LIMIT` = 30,000,000 of it regular, and reads the reservoir a result settled with (`AdditionalLimit::reservoir_remaining`), which the fork no longer does.
+
+## Running the checks
+
+Commands are in [`AGENTS.md`, "Build & Development Commands"](../../../AGENTS.md#build--development-commands) and the gates in [`AGENTS.md`, "Test Gates"](../../../AGENTS.md#test-gates).
+Four notes that are easy to miss:
+
+- the `mega-evme` tests run with `--manifest-path bin/mega-evme/Cargo.toml`, not `-p`;
+- run the suite with `MEGA_SATIN_CPSB` and `MEGA_SATIN_CPHB` unset, or the tests that pin the spec's byte prices skip;
+- after any test change, run `scripts/price_grid.sh --pr`;
+- the execution-spec gate needs Ethereum's fixture releases, at the versions `.github/workflows/exec-spec-satin.yml` downloads.
+
+Evidence that a change alters no result: `state-test --json-digest` at two commits, detached, over both fixture releases, in equivalence mode, in Satin mode and in Satin mode under tighter limits (the `--limit-*` options), each sorted and compared byte for byte, plus the gates and the byte-price grid.
+The digest hashes each transaction's whole outcome, its gas by ledger and its usage counts included, so it catches a shift between ledgers that `--json-outcome` does not.
+A golden or snapshot changes only for a stated reason: regenerate it and read the diff.
+
+## Reading order
+
+1. The consensus core: limits (the vocabulary of pool, record, stop and crossing), then execution and frames with gas detention, then the block executor, then the system contracts and system address.
+2. The gas schedule and pricing.
+3. The inspector contract.
+4. The node surface, validation and the witness.
+5. Tools, tests, goldens and CI.
+ Skim the goldens and snapshots; read what changes them.
+
+Skim without reading: the SALT bucket-hasher internals, the generated pricing table, the tracer snapshots, the receipt goldens and the keyless differential digest.
+The module documentation at the top of the main source files states the same invariants as the lists below, often more exactly; where an entry names what to read first, start there.
+A test name or a line count is not a reason to trust the code: read the code against the spec.
+
+## Glossary of the terms the checks use
+
+- **Live system address**: the address the `SequencerRegistry` names (`_currentSystemAddress`).
+ `MEGA_SYSTEM_ADDRESS` in code is only the address the registry named when Rex5 created it, which a chain's registry holds until a rotation.
+- **Pre-block caller**: `0xff…fe`, the EIP-4788 system address, the caller of the pre-block system calls.
+ It is a different address from the live system address.
+- **MST** (Mega System Transaction): a signed legacy transaction from the live system address to a whitelisted system contract (today the Oracle), promoted to a deposit by the engine.
+- **System-originated** (spec §19, `originates_from_the_protocol` in `src/system/tx.rs`), decided from the transaction's own fields:
+ an MST before or after promotion; any transaction whose caller is the pre-block caller; any deposit carrying the source hash the promotion stamps, `keccak256("MEGA_SYSTEM_TRANSACTION")`, whoever sends it.
+ Such work is exempt from history gas, every per-transaction limit and frame budget, and detention, and priced at the minimum bucket; its usage is still counted.
+- **Pool**: a frame's budget in data size, KV updates or state growth, held on its `GasTracker`; the fork forwards a child its share at the start and settles the child's pools on its return, as it does the reservoir.
+- **Write record**: one per account or storage slot the transaction keeps changed, by the net change; 40 bytes of data size and of history; the KV count.
+- **State growth**: the net count of new accounts and new slots the transaction keeps.
+- **Stop**: what a limit does.
+ The frame that crosses it reverts with `MegaLimitExceeded(kind, limit)`, and its caller resumes and may catch it.
+- **Answered frame**: a frame that gets a result without running (a precompile, a call to an account with no code, an interceptor, the engine, an inspector's hook).
+- **Start charge**: the history gas a frame start charges its caller for the records the started frame makes, declared on the start and refunded by the fork when the frame fails.
+- **Failed-charge record**: the regular gas a frame had before a charge that failed, which the fork keeps, so the engine knows exactly what a halting frame burned.
+- **Byte-price grid**: the CI job that runs the suite at other costs per state and history byte, because the prices are provisional.
+
+## Module map
+
+Paths are relative to `crates/mega-evm/` unless they start with another top-level directory.
+For each module: where it is, what to check, the spec sections, and the `AGENTS.md` subsection with the detail.
+
+### Limits: data size, KV updates, state growth, the stop
+
+- **Where:** `src/limit/` (the byte table, `LimitKind`, `LimitCheck`, `MegaLimitExceeded` and `EvmTxRuntimeLimits` in `mod.rs`; the write records and the state growth a write and a frame start make in `record.rs`; `AdditionalLimit` in `limit.rs`), `src/block/limit.rs` (`ProtocolLimits::for_spec`, `BlockLimits`, `BlockLimiter`), `src/constants.rs`.
+- **Read first:** the module doc of `src/limit/mod.rs` and the doc of `AdditionalLimit` in `src/limit/limit.rs`.
+- **Check:**
+ - A count is drawn where it is made, on the pool of the frame that makes it (`AdditionalLimit::draw`), and a failed frame's draws go back with its gas.
+ - The transaction's limits are held beside the pools, on what the transaction keeps (`AdditionalLimit::usage`): the body, the hints, the authorities' records and the accounts they created, a deposit's created caller, and what the frames keep, restored when a start's frame keeps nothing (`AdditionalLimit::close_start`).
+ - A completed write and a decided start are held in one function (`AdditionalLimit::check`, through `draw` and `count_start`): in the order data size, KV updates, state growth (`limit::COUNTED`), the frame budget, then the transaction limit; a hint, the authorization list and a caller's hold at a child's return check the same limits directly.
+ - The stop names the budget when the budget is crossed, and the transaction limit only when it is not, which a framed write reaches only in data size, after Oracle hints used what the transaction had left; a start names it too when a deposit-like transaction's created caller stands on a state-growth limit of nothing, which only a tool's limit sets.
+ - Every stop comes from `AdditionalLimit::crossed`, which also applies the exemption of system-originated work and system calls.
+ - A write record follows the net change: an account's while its nonce, balance or code differs from what the transaction loaded, a slot's while its value differs from its original; the sender's account and the fee credits the settlement makes are the body's, not records.
+ - A creator's nonce record is counted on the creator when the creation returns with the nonce bumped, held to the creator's budget, and survives the creation's failure; the creation's budget is the share taken at the opcode, before it.
+ - State growth rises by one at each EIP-8037 account-leaf or fresh-slot charge site and for the caller a failed deposit creates, and a slot written from an original zero back to zero falls by one; a frame's net is signed, a negative net never enlarges a child's budget (`cap_the_shares` in `src/evm/execution.rs`), and a transaction reports `max(net, 0)`.
+ - The first effective `SELFDESTRUCT` of an account created in the transaction applies the destruction table: each part absent at the transaction's start (a slot by its original in the transaction, a leaf by no account standing there) and present before the destruction is refilled at the price it was charged, to the destroying frame, the leaf and each such slot lower state growth by one and lose their write records, and the code's data size and history gas are taken back; from the mark the account adds no further state growth, state gas or write record, and a failure of the destroying frame, or of a frame that contains it, discards it all.
+ - A caller resumed after its child's crossing is held to what the transaction has left, and stops in turn if a count or a charge of its own crosses again; a caller a failure below it left over the transaction's data-size limit, a hint having filled room a take-back freed, returns the transaction's stop before its next instruction (`AdditionalLimit::hold_caller`).
+ - `LimitKind` keeps Rex6's encoding: data size 0, KV updates 1, compute gas 2, state growth 3.
+ - Limits are per-spec constants, never chain configuration; a bare `MegaContext` runs under them; `BlockLimits` is builder policy and can only tighten.
+ - `KV × 40 ≤ data size` holds after every instruction.
+ - An EIP-7702 list long enough to cross the KV-update or state-growth limit is simulated whole before the first frame, writing and warming nothing; one that would cross is skipped whole, and the transaction's own frame is stopped before it runs (`hold_authorization_list` in `src/evm/execution.rs`); a shorter list cannot cross and is applied as EIP-7702 applies it.
+ - A hint that would cross the limit is neither counted nor forwarded; an admitted hint stays counted through any stop.
+- **Spec:** §7, §10, §11, §19, §20.
+- **Detail:** [`AGENTS.md`, "Contracts of the common execution layer"](../../../AGENTS.md#contracts-of-the-common-execution-layer).
+
+### Execution and frames
+
+- **Where:** `src/evm/execution.rs` (`MegaHandler`; `MegaEvm`'s frame start and return, `frame_init` and `frame_return_result`, and the run-result hook `frame_run_result`), `src/evm/host.rs` (the completed-write and frame-start hooks), `src/evm/context.rs` (`MegaContext`, `spec_cfg`, `admit_code_deposit`), `src/evm/mod.rs`, `src/evm/state.rs`, `src/evm/instructions.rs`, `src/evm/frame.rs`, `src/evm/result.rs`.
+- **Read first:** the docs of `frame_init` and `frame_return_result` in `src/evm/execution.rs`, and the module doc of `src/evm/host.rs`.
+- **Check:**
+ - A write is counted in the Host's completed-write hook (`write_completed`), which revm calls only once the opcode made every charge, so a failed opcode counts nothing; the Host's write methods count nothing, whoever calls them.
+ - A completed write's record is held to the limits before its history is charged, so a record a limit refuses is not charged; at a frame start the order is the other way round, the caller paying at its opcode before revm decides the start and its records are held.
+ - The frame-start hook (`frame_starting`) charges the caller the history of the start's records after the forward is taken, out of what the caller kept, and declares the frame's own part on the fork's start (`FrameStart::charge`); a caller that cannot pay gets the forward back, the halt's record re-written, and starts no frame.
+ - A start's records, state growth and transfer log are read off what revm did: its accounts before revm decides the start and again once it did (`FrameStart::of` and `FrameStart::count` in `src/evm/execution.rs`, `Accounts::start_before` and `start_made` in `src/limit/record.rs`), counted on the started frame's pools (`AdditionalLimit::count_start`) for a frame revm built or a call it answered with a success; an answer that failed counts nothing and is held to no records limit, and a precompile gas detention answers from its price counts nothing and is held to the price alone; a start revm refuses on its caller's account counts nothing and is charged nothing.
+ - A frame revm built whose start crossed a limit ends with the stop before its first instruction (`end_before_it_runs`); a success revm gave without building a frame gives way to the stop on its untouched forward, its value move and log taken back to the start's journal mark (`stop_the_answer_at`, `take_back_a_stopped_answer`); an answer that failed is revm's result, held to nothing.
+ - Pre-frame charges (a deposit's caller account, EIP-7702 authorities, pre-frame records) either succeed or leave an included out-of-gas halt without a frame, with the journal unwound as revm unwinds it (a creation keeps its nonce bump).
+ - A deposit that fails validation or cannot pay a pre-frame charge is included as a failed deposit: whole gas limit used, mint credited, nonce bumped.
+ - The forwards: regular gas `remaining − remaining × 2 / 100`, plus a value call's stipend after the cap; the reservoir by the same subtraction, the transaction's own frame and a system call's outermost frame taking the whole; each pool `remaining × 98 / 100`, rounded down.
+ - `spec_cfg` fixes the configuration whatever the caller passes (Satin schedule, EIP-8037, EIP-2780, execution cap 200,000,000, EIP-7708, chain-id check on, the contract size limit at 512 KiB and the initcode size limit at 1 MiB, the fork's legacy journal semantics off).
+ - Per-transaction state resets with the transaction; a system call has its own entry point, and the handler splits its gas (`MegaHandler::tx_gas`).
+ - A fact about the transaction's start is read with what the journal records of the transaction (its original info, its entries, its transaction id), never off an account flag revm sets once per journal alone, so on a journal that runs several transactions unfinalized the engine's counts follow what revm charges there.
+- **Spec:** §3, §4, §5, §9, §10, §11, §14, §21.
+- **Detail:** [`AGENTS.md`, "How Satin executes today"](../../../AGENTS.md#how-satin-executes-today).
+
+### Gas detention
+
+- **Where:** `src/access/` (`Detention`, `VolatileDataAccess`), the volatile-read wrappers in `src/evm/instructions.rs`, the loads the Host marks or refuses in `src/evm/host.rs`, `hold_precompile`, `settle_answer` and `end_frame` in `src/evm/execution.rs`, the switch in `src/system/control.rs`.
+- **Read first:** the module doc of `src/access/mod.rs`.
+- **Check:**
+ - The split into spendable and withheld gas is applied when a read completes, when a frame starts or resumes, and after an `SSTORE`; only regular charges are held to the spendable part, every other reader sees both.
+ - The withheld part goes back to the sender unspent, except from a failed deposit.
+ - A crossing is classified in the run-result hook (`frame_run_result`, `Detention::on_frame_end`), and only on an out-of-gas: the frame's gas is put back to what it was before the charge, the frame stops with `MegaLimitExceeded(2, limit)`, and its caller gets everything the frame had.
+ - Compute is every regular charge the frames make, the work run on a value call's stipend included, less the state and history gas that spilled onto regular gas, and less what halting frames burned, which is read off the fork's failed-charge record.
+ - A value call's own regular charges are decided first, and stop the calling frame if they cross; a precompile is then decided from its price before it runs, and one the engine cannot price runs on the allowance.
+ - What is volatile: the block environment (`SLOTNUM` and `BLOCKHASH` among it, `BLOBHASH` not), the block beneficiary's account, the Oracle's storage; a call to the EIP-2935 history contract reads the block number, and a `CREATE`'s loads of its creator and created address are no reads.
+ - A system-originated transaction and a system call are never detained.
+- **Spec:** §12, §13.
+- **Detail:** [`AGENTS.md`, "Gas detention"](../../../AGENTS.md#gas-detention).
+
+### Block executor and block rules
+
+- **Where:** `src/block/` (`executor.rs`, `limit.rs`, `result.rs`, `eips.rs`, `l1_block_info.rs`, `factory.rs`, `helpers.rs`).
+- **Read first:** the module doc of `src/block/executor.rs`.
+- **Check:**
+ - The activation-block rule is caller-set (`no_user_tx_activation_block`, default `false`); `MegaHardforks::admits_only_deposits` is what a builder computes it from.
+ - A transaction is an MST when it is a legacy transaction of the system shape from the live system address, decided before it runs; a failed read of the address is an internal error.
+ - The block's packing budgets are data size 13,107,200, KV updates 500,000 and state growth 1,000, checked in that order before a transaction runs (`BlockLimiter::pre_execution_check`): the transaction that reaches one is packed, and every later ordinary transaction is refused.
+ - A deposit and an MST are never refused by the packing budgets or building policy and count towards them; both are held to the header gas limit (`BlockLimiter::pre_execution_check`), and an MST, a legacy envelope, to the DA footprint (`check_da_footprint`), which a deposit is exempt from.
+ - `commit_transaction_outcome` checks the counters again and refuses a stale outcome: the sender's nonce or balance moved since the candidate executed (`StaleOutcome`, internal).
+ - Pre-block order: EIP-2935, EIP-4788, in Satin's activation block alone the check of the six system contracts and the EIP-7997 factory, the registry's due change, the read of the L1 block info.
+ - Every pre-block call runs through one helper (`transact_pre_block_call` in `eips.rs`) on `PRE_BLOCK_CALL_GAS_LIMIT`, whatever the block's gas limit; one that does not succeed makes the block invalid, and a database error the database declares fatal is an internal error.
+ - The pre-block calls count towards no block budget.
+ - Block execution admits any inspector; the node decides which run on block production.
+ - The block's counters: regular gas as `max(regular, floor)`, state and history gas, history bytes, data size, write records and state growth; the three gas ledgers are reported, not limited.
+ - When the OP base moves, diff the file against the new base's `OpBlockExecutor`.
+- **Spec:** §1, §18, §19, §20, §21.
+
+### System contracts and the system address
+
+- **Where:** `src/system/` (`intercept.rs`, `oracle.rs`, `control.rs`, `limit_control.rs`, `keyless/`, `tx.rs`, `predeploys.rs`, `sequencer_registry.rs`), `crates/system-contracts/`.
+- **Read first:** the module doc of `src/system/tx.rs`.
+- **Check:**
+ - Every transaction reads the registry's account and its `_currentSystemAddress` slot, warm, by comparing the code hash, without running the registry's code.
+ - A transaction from the live system address without the system shape is invalid; a deposit from it, which never has the shape, is a failed deposit, including one carrying the MST source hash.
+ - A deposit carrying the MST source hash from any **other** sender is not refused: it is system-originated, so it is held to no limit, pays no history gas, is not detained and is priced at the minimum bucket.
+ The spec's basis is that no deposit derived from L1 carries the hash.
+ This is the widest exemption in the engine, so check that claim.
+ - An MST is validated (chain id, nonce, EIP-3607) before it is promoted to a deposit.
+ - Satin deploys, upgrades and seeds no predeploy.
+ The block in which Satin activates (`MegaBlockExecutionCtx::satin_activation_block`, set by the node from its schedule and the parent's timestamp) reads the seven, each a read-only entry, and each must hold exactly Satin's code whatever its nonce, balance and storage.
+ Anything else — no account, no code, an older version (the Oracle's 1.0.0 / 1.1.0, the registry's 1.0.0), other code — makes the block invalid with one error, `UnexpectedSystemContractCode`.
+ No other block reads them.
+ - An Oracle read in a system call reads chain storage, never the oracle service.
+ - Keyless: the call runs as a native creation of the recovered signer; an empty code deposit at the deploy address is refused with `EmptyCodeDeployed`, a constructor's inner creation returning empty code is not; the answers are the documented error set.
+ - The keyless creation forwards `min(gasLimitOverride, remaining)` of regular gas, the reservoir share of what the call has left and the child share of each of the call's pools; the signer's nonce record is counted on the call at its settlement, once the creation returned.
+ - The interceptor dispatch order is scheme guard, address, selector, then value policy; an unknown selector is not intercepted.
+ - Deployed bytecode and code hashes match the attested artifacts (`build.rs`).
+- **Spec:** §13, §15, §16, §17, §18, §19.
+
+### Gas schedule and pricing
+
+- **Where:** `src/evm/schedule.rs`, `src/evm/prices.rs`, `src/evm/history.rs`, `src/evm/precompiles.rs`, `src/external/` (SALT pricing), `state_gas_price` in `src/evm/host.rs`, the Amsterdam opcode activation in `src/evm/instructions.rs`.
+- **Check:**
+ - Every regular entry is Amsterdam's; state creation is paid once, in state gas.
+ - The forwards are schedule entries: `call_stipend_reduction` = 50 (the regular-gas cap), `reservoir_kept_percent` = 2, and `pool_kept_percent` = 2 for each of the three pools; the neutral configuration keeps EIP-150's 63/64 and forwards the whole reservoir.
+ - State gas = schedule entry × bucket multiplier `m`; regular gas never scales.
+ A failed capacity lookup is a node fault: the transaction gets no outcome and is not settled, and the node reports an internal error with the cause.
+ - History gas uses the limit layer's byte table, so a record's history bytes are its data size; the three sites where the totals part are in the `src/limit/mod.rs` module doc, "The byte table".
+ - A deposit, a protocol-produced transaction and a system call pay no history gas.
+ - The history allowance (`HISTORY_ALLOWANCE_BYTES`, 160 bytes; `history_allowance_gas()` in `src/evm/history.rs`, the schedule's `call_history_allowance`) draws only on a log's charge.
+ - The EIP-7623 floor is still computed and validated.
+ - The constants are provisional; a build with `satin-price-override` must never reach a node.
+- **Spec:** §2, §4, §5, §6, §7, §8, §9.
+
+### Inspector contract
+
+- **Where:** the `evm` module documentation (`src/evm/mod.rs`, "Inspectors") and `src/evm/execution.rs` (`frame_init`, `frame_run_result`, `frame_return_result`; `frame_run` and `InspectorEvmTr` are revm's), `test_utils::ReadOnlyObserver`.
+- **Check:**
+ - The module documentation of `src/evm/mod.rs` is the contract (the spec does not describe inspectors): an inspector runs on revm's inspected lifecycle unchanged, and every per-frame mechanism sits in the frame start, run result or return both loops share.
+ - A rewritten result is taken as given: the caller settles it as revm does, with no correction of the engine's.
+ - An inspector's answer never reaches the engine's frame start, so the depth guard, the interceptors and gas detention see none of it, and it settles on the gas it is built on.
+ - A frame that crosses the compute limit is seen to end with the stop: the stop is made in the fork's run-result hook (`frame_run_result`), before the inspector's `call_end`, `create_end` and `frame_end`.
+ - A `keylessDeploy` call's frame is handed to no `initialize_interp` and gets no `step`: the inspector sees the call start, its creation, and the call end.
+ - A start an inspector rewrites after its opcode is not charged again: what the opcode charged stands, its declared part coming back only as for any start whose frame keeps nothing (a frame that fails, or a start revm refuses before it bumps a nonce or moves a value), and its records are those revm then made.
+ - A pre-block system call runs on the plain system-call path, with no callback.
+ - `test_utils::ReadOnlyObserver` checks, in debug builds, that an inspector a test declares an observer writes nothing back: a tripwire for tests, not a proof.
+- **Detail:** [`AGENTS.md`, "Contracts of the common execution layer"](../../../AGENTS.md#contracts-of-the-common-execution-layer), the entries on inspectors.
+
+### Node surface, validation and the stateless witness
+
+- **Where:** `src/lib.rs` (explicit exports), `src/block/hardfork.rs`, `src/block/chain.rs`, `src/block/genesis.rs`, `src/evm/validation.rs`, `src/evm/state.rs`, `src/block/l1_block_info.rs`, `src/test_utils/witness.rs`, `crates/mega-state-test/src/witness.rs`.
+- **Check:**
+ - `validate_schedule` refuses a schedule in which a base fork Satin runs on is not active by `satinTime`.
+ - The genesis format has exactly one key, `satinTime`; Satin carries no parameter, and every other `satin*` key (the old registry and limit keys included) is refused.
+ - A key given twice is read as its last copy by every reader, and `satinTime` is also read from the `arbitrary_precision` object form, decimal digits alone.
+ - The pool and the engine refuse the same oversize body with the same error (`TX_BODY_OVER_DATA_SIZE_LIMIT`): body + 40 × authorizations over the transaction limit.
+ - The witness holds every read: block hashes, SALT bucket ids, the Oracle reads of the block's transactions (none for system calls), the L1 block info, the registry, and every authority the authorization-list simulation loaded.
+ - The witness is the sequence of states the block commits: each pre-block step commits its state on its own, read-only entries included, where a commit hook on `State` receives it whole; nothing else hands the pre-block states out.
+ - A witness replay's exports are a subset of the building node's, and may be a proper one.
+ - A node's database answers an address it holds no account for as no account (`None`), never as an empty account: the destruction table gives a leaf back only when no account stood there.
+- **Spec:** §1, §21, §22, "Node integrators".
+
+### Tools, tests, goldens, benches and CI
+
+- **Where:** `bin/mega-evme/` (`bin/mega-evme/src/engine.rs` picks the engine from `--spec`: Satin in-tree, legacy specs on a released crate; `run` and `tx` default to the legacy `Rex6`), `crates/mega-state-test/`, `crates/state-test/`, `crates/mega-evm/tests/` (`satin/`, `block/`, `system/`, `fuzz/`, `tracers/`), `crates/mega-evm/benches/`, `.github/workflows/`, `scripts/`, `mutants/suppressions.toml`.
+- **Check:**
+ - No consensus path changed for a tool's sake; tool overrides (`--override.limits`, `with_tx_runtime_limits`, `with_protocol_limits` under `test-utils`) are explicit and never default.
+ - A limits file of the first shape, without the KV-update and state-growth fields, reads with the default spec's values for them; every other field stays required, and an unknown one is refused.
+ - `state-test --json-digest` hashes each transaction's whole outcome, and the `--limit-*` options run Satin mode under tighter limits in each dimension.
+ - A test pins a spec rule, not the implementation; a new or changed test says which rule it checks (some headers carry a `[S.]` tag: the spec section and item).
+ - A figure the schedule determines is asserted against its derivation, not pinned; snapshots and goldens own only outputs with no computable expectation.
+ - The limit matrix (`tests/satin/limit_matrix/`) runs every row, none of them ignored.
+ - `mega-evme`'s recorded mainnet blocks are one deterministic archive, `bin/mega-evme/tests/fixtures/blocks.tar.xz`, extracted once per test binary into cargo's target scratch directory, each file moved into place on its own so racing extractions all succeed; `bin/mega-evme/scripts/pack_blocks_fixture.py --check` holds a repack of it byte-identical.
+ - The suite passes at the byte-price grid's points, not only at the spec's prices.
+ - The mutation gate is fail-closed: a suppression without a locator may cover only one mutant.
+ - A fuzz run that checks nothing fails (zero cases, zero comparisons).
+
+## Judging a finding
+
+1. **Reachability first.**
+ Does the node's block execution or building path reach it?
+ With the default configuration, or only with a non-default limit?
+ Is it decided below?
+2. **Severity**, in this order:
+ 1. not reachable from block execution or building: at most low (tools, test APIs);
+ 2. reachable only with a non-default configuration: one level lower;
+ 3. already decided below: not a new finding; say what is new about it;
+ 4. only an error kind or text differs, with no effect on state root, receipts, gas used, logs or block validity: not a consensus defect;
+ 5. can halt the chain (an activation-block error, a pre-block failure, a valid deposit refused): high, whatever the likelihood.
+3. **A claim in the pull request description**: turn it into a checklist item and verify it with `file:line` against the final code.
+4. **A mechanism** is open to question unless the Satin design settled it: ask what problem it solves, whether that problem still exists, whether a native replacement exists, and how it could be simpler.
+5. A consensus defect is a difference in state root, receipts root, gas used, logs or block validity between two honest nodes, or between the engine and its specification.
+
+## Revert or halt
+
+Read this before rating a finding that says a failure reverts where it should halt, or halts where it should revert.
+
+A refusal the protocol imposes reverts; an execution fault halts.
+Every limit stop — the transaction's data-size, KV-update and state-growth limits, a frame's budget in those three, gas detention's compute limit — reverts the frame that crosses it with `MegaLimitExceeded(uint8 kind, uint64 limit)` on the frame's own gas, so the unspent gas goes back to the caller, its reservoir and pools included, and the caller resumes and may catch the stop.
+An execution fault — a real out-of-gas, a precompile given less than its price, an invalid opcode, a charge the frame cannot pay — halts and consumes the frame's gas, as in revm.
+One ABI serves every kind of stop, and there is no third ending: the halt reasons are op-revm's (`MegaHaltReason`), and the engine makes no halt of its own.
+An operation that crosses several counted dimensions at one site stops on the first of data size (kind 0), KV updates (kind 1) and state growth (kind 3); compute (kind 2) is decided at the regular charge, before the write is counted.
+Inside a dimension the frame budget is tested before the transaction limit, and the stop names the budget whenever the budget is crossed.
+
+The deliberate exceptions:
+
+| What happens | Why |
+| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| A deposit that fails validation — its body over the data-size limit, or sent from the live system address — or that cannot pay a charge made before its first frame, or whose own frame halts, is included as a failed deposit: its whole gas limit billed, its nonce bumped, its mint kept, nothing else applied, no stop reported. | The OP stack's deposit rule: a deposit comes from L1, where its gas was paid, and must be included, so it can be neither rejected nor caught by a caller. |
+| An input over one of Optimism's precompile input-size limits (the BN254 pairing, the BLS12-381 MSMs and pairing) is refused before any gas check: the call halts and burns its forward. | The Optimism precompile specification, inherited with the Karst set, makes the size check the precompile's own input check, which fails the call like any bad input, and gas detention prices such an input at zero, so it is never a crossing. |
+| Under gas detention two precompile faults end as the compute stop instead of a halt: a priced precompile whose price is past the allowance and within the forward is not run, even when its input would fail a check made after the gas check; and a precompile the engine cannot price (one a node added or replaced) that runs out of the allowance is the stop, even when its price is past the whole forward. | revm runs a precompile inside the frame's start, so the engine must decide before it runs and decides from the price, which says nothing of a check made after the gas check, while a precompile without a price can only be run on the allowance, and running out of it is all the engine sees. |
+| Changed after #407 merged: a call whose start (its value transfer's records and transfer log) crosses a data-size, KV-update or state-growth limit gets the stop on its untouched forward when revm built its frame or answered it with a success; a call revm answered with a failure — a precompile that fails after the value moved — kept nothing and halts as revm has it, burning its forward, and a precompile gas detention answers from its price is the compute stop, whatever its records would have crossed. | A limit is enforced at the writes it guards, which are what the journal kept: a success kept the start's writes, so it gives way to the stop; a failure's writes revm took back, and a precompile answered from its price moved nothing, so neither has a write to hold. |
+| A frame answered without running (an interceptor's answer, or a `keylessDeploy` call refused for carrying value) that spent more regular gas than the frame's allowance is the compute stop, and none of its spending is billed, the part within the allowance included, where a frame that ran keeps what it spent before the charge that crossed. | An answer is one step with no point inside it where the allowance ran out, so its whole spending is the charge that crossed, and a charge that crosses is never made; of the engine's own answers only the `keylessDeploy` refusal spends regular gas, its overhead. |
+| Refusals that are not limit stops revert with their own error, not `MegaLimitExceeded`: `VolatileDataAccessDisabled(uint8)` (the opcode's static gas paid, nothing else; 12 for `SLOTNUM`, outside the contract's enum), `DisabledByParent()`, `NonZeroTransfer()`, `NotIntercepted()`, keyless deployment's rule errors, and revm's `CallTooDeep` and `OutOfFunds` with empty data, all of them catchable, with the outcome's `limit_exceeded` left empty. | They refuse what the caller asked for, not a resource the transaction ran out of: each names its reason in the ABI its contract, keyless deployment or revm already defines, so a caller can tell it from a stop. |
+| One size rule has three endings: initcode over the size limit is rejected at validation in a non-deposit creation transaction, halts the creating frame at `CREATE` or `CREATE2`, and reverts a `keylessDeploy` call with `InitCodeTooLarge(size, max)`; deployed code over the code-size limit halts the creation, while deployed code within it that takes the transaction or the frame over the data-size limit is the stop. | The size halts are Ethereum's (EIP-3860 for initcode, EIP-170 for deployed code) at MegaETH's sizes, rules of the EVM rather than MegaETH's resource limits, so they stay halts, while a keyless call checks the init code among its rules before any creation starts and every rule refuses with a revert and its own error. |
+
+Not exceptions, but easy to mistake for one:
+
+- A transaction that cannot pay a charge made before its first frame — the account a deposit-like transaction creates for its caller, an EIP-7702 authorization's charges, the history of the records made before the first frame — ends out of gas with no frame: its whole regular budget is consumed and its reservoir returned.
+ That is EIP-2780's runtime out-of-gas path, a gas fault (`pre_execution` in `src/evm/execution.rs`).
+- An EIP-7702 list that would take the transaction over its KV-update or state-growth limit is skipped whole, and the transaction's own frame is stopped before it runs, naming the transaction limit (kind 1 when both would cross).
+ The crossing happens before any frame, yet it is a limit stop, where Rex6 halted; the intrinsic gas, the body's history and its data size stay, and nothing of the list is kept.
+- A deposit whose own frame is stopped settles as a revert, like any transaction's, and is not a failed deposit.
+- A failed deposit that creates its caller counts that account as one unit of state growth, for the transaction and the block, and no limit stops it: it has already failed.
+- A keyless creation that reverts, halts or is stopped makes the `keylessDeploy` call succeed, with `ExecutionReverted`, `ExecutionHalted` or `EmptyCodeDeployed` in its ABI return, a stop's revert data carried inside `ExecutionReverted`.
+ The call itself reverts with the stop only when its own charges or the signer's nonce record cross a limit; otherwise `answer` in `src/system/keyless/settle.rs` builds its ABI return when the creation returned (`frame_return_result` in `src/evm/execution.rs`).
+- Under gas detention, only a regular charge the withheld part would have paid is a crossing; a charge beyond the frame's whole regular gas, and a failed state or history charge, halt as they would without the read.
+- Under gas detention, a value call whose own charges cross stops the calling frame before anything moves, whatever its target and whether or not the caller can fund the value.
+- A creator that its creation's nonce record takes over a limit is stopped when the creation returns, before it runs another instruction, whatever the creation's own result.
+- A frame a failure below it left over the transaction's data-size limit — the failure put back a record of a frame above, and a hint the failed frame sent stays — is stopped as it resumes, before it runs another instruction, whether the frame below reverted, halted or was itself stopped.
+- The destruction table's give-back crosses nothing; the operation's positive effects are held after it, in the order data size, KV updates, state growth, and one that crosses stops the destroying frame, which then keeps nothing of the operation; a regular charge of the `SELFDESTRUCT` that crosses gas detention stops the frame before the opcode completes, and none of the table applies.
+
+## Already decided — do not re-report
+
+Each is a decision with its reason; "in this pull request" means review the code, not the decision.
+
+- **KV updates and state growth are limited, per transaction, frame and block; state gas and the block's execution gas are not**: the count, not the gas, stops the 1,001st slot, and the KV check is made though at Satin's constants data size binds first.
+- **Consensus limits are one per-spec table** (`ProtocolLimits::for_spec`), not chain configuration: configured values could stop the L1-attributes deposit and cost a silent factory fallback.
+- **No latch**: a crossing is a native revert of the crossing frame, which callers may catch, and a caller that runs on is held to what the transaction has left, so no transaction keeps more than its limits.
+- **An oversize transaction body is refused at validation** (a deposit becomes a failed deposit): the body is known before execution, and at Satin's constants the bound is unreachable (6,732,889 < 13,107,200).
+- **An EIP-7702 list over the KV-update or state-growth limit is skipped whole** and stops the first frame before it runs: Rex6's all-or-nothing rule, as a revert-class stop, because a stop of the first frame does not revert what was applied before it.
+- **The stop names the frame budget when both the budget and the transaction limit are crossed**; when a block is full on several budgets, a node may name them in the order data size, KV updates, state growth, and two nodes need not name the same one.
+- **`tx_chain_id_check` is pinned on**: it is revm 40's default, and it makes the system-transaction chain-id guard effective.
+- **Every transaction pre-warms the registry read**, so gas does not depend on the envelope type; the non-warming journal read is not a generic upstream candidate.
+- **A delayed commit re-checks only the sender's nonce and balance**: other staleness is the builder's documented responsibility, as the system-transaction-first flow requires.
+- **An MST is never refused by a packing budget or builder policy**: it serves a user transaction already admitted.
+- **Satin has no deploy or upgrade path**: it runs on a chain that ran the legacy forks, and its activation block refuses any predeploy without Satin's code; no contract changes.
+- **Keyless refuses only an empty code deposit** at the deploy address; the four producer-less errors are deleted, which changes no deployed byte.
+- **A rewritten result is taken as given, as revm takes it**: a revived creation settles as the success the inspector made of it (Foundry parity), and an inspector's answer settles on the gas it is built on.
+- **The Amsterdam regular gas table is taken wholesale**: the earlier press-back to Osaka priced creation twice.
+- **`validate_schedule` checks that base forks are active by `satinTime`**; engine-built schedules activate them from the first block, which no Satin block can tell apart.
+ An unknown chain has no schedule (`hardfork_schedule` answers `None`).
+- **Block execution admits any inspector**: which inspectors run on block production is the node's decision.
+- **Explicit crate-root exports; dead helpers and legacy-era remnants are deleted.**
+- **Satin carries no fork parameter**, and the fork-parameter mechanism was removed with nothing using it.
+- **An absurd state-gas price makes the operation run out of gas**; no reachable divergence.
+- **The pending-changes due check uses the direct-read convention** (any database error is an internal error), as the other direct reads and upstream do.
+- **Precompile prices are looked up by id**: a precompile set replaced around the engine, through the mutable accessors, keeps the built-in prices; the spec states the boundary, and nodes change the set through `with_dyn_precompiles` or the factory builder.
+- **A keyless signer that is the block beneficiary is detained**, as in the legacy engine.
+- **No MST in the activation block**: it admits only deposits and every MST consumer is a non-deposit; documented in the spec.
+- **Write records follow the transaction-wide net change**, not Rex6's per-operation count: the record measures the state the transaction keeps, which is what history gas prices.
+- **The limit override is an explicit tool opt-out** (`with_tx_runtime_limits`); block execution and validation use the chain's limits.
+- **No spec ladder in Satin yet**: it comes with the next spec, with the extension points kept; `AGENTS.md` says how to add it.
+- **The fork finalizes the journal on an error** (`bluealloy/revm#3780`, carried early): kept; the fork documents it in megaeth-labs/revm#75.
+- **`OpBlockExecutor` is not composed**: it requires `PostExecEvm` and returns `OpTxResult`.
+- **The 98/100 shares and dropping a hint from a frame whose volatile access is off are kept**: without a latch the frame budgets and the reservoir share protect the caller's own work.
+- **The neutral configuration forwards as Ethereum does** (EIP-150's 63/64, the whole reservoir): equivalence mode is Ethereum's forward, not Satin's.
+- **An inspector's answer built on `Gas::new(limit)` carries no reservoir and unlimited pools**, so above the execution cap its caller keeps only the 2 per cent of its reservoir it kept, and the caller's budgets are lifted for the rest of its frame: tools only, kept.
+- **Satin does not apply EIP-7610's storage collision**: the engine reads storage slot by slot and cannot see storage it has not loaded; the execution-spec gate skips those fixtures.
+- **The destruction table refills state gas, which EIP-8037 does not**: a part the transaction made does not remain for a node to store.
+- **The table's slot column follows the transaction's original**: a slot of a created account first accessed after the creation is zero at the start whatever the state held, as revm loads it; only a slot accessed before the creation keeps its value, and the specification says so.
+- **The neutral configuration counts the destruction table**, and prices it as the fixture's fork does: equivalence mode's usage of a transaction that creates and destroys an account differs from a count without the table, no fixture checks usage, and no second counting rule is kept for the neutral configuration.
+- **`BLOBHASH` is not volatile**, unlike in Rex6: it reads the transaction's own blob hashes.
+- **The pre-block calls run on one constant budget** (`PRE_BLOCK_CALL_GAS_LIMIT`), not on the block's gas limit.
+- **Mechanisms whose existence is kept from the legacy engine** (whether to have them is not under review; their Satin rules, which the specification states against Rex6, are): `MegaAccessControl`, gas detention's two categories and 20M caps, `remainingComputeGas()`, the Oracle, keyless deployment, the Mega System Transaction, the registry and rotation, the high-precision timestamp, SALT bucket pricing, the history allowance, the 98/100 frame share and Rex6's numbers for the data-size, KV-update and state-growth limits, the 200M execution cap with 512 KiB code size and the KZG price, the deposit-caller account charge, the DA footprint.
+- **The upstream revm change `new_answer`** for answers to frames that did not run (`bluealloy/revm#3979`) is opt-in: the handler does not normalise answers, because real inspectors' answers can have effects.
diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md
index 0f99d22da..b5bbb2f1c 100644
--- a/.github/pull_request_template.md
+++ b/.github/pull_request_template.md
@@ -10,5 +10,7 @@
+
+
diff --git a/.github/scripts/bench_compare.py b/.github/scripts/bench_compare.py
deleted file mode 100644
index ba3a225e5..000000000
--- a/.github/scripts/bench_compare.py
+++ /dev/null
@@ -1,576 +0,0 @@
-#!/usr/bin/env python3
-"""Aggregate paired, order-interleaved A/B benchmark rounds into a drift-robust
-comparison comment.
-
-The old harness ran the whole feature suite, then the whole baseline suite, and
-compared two single point estimates. Those two passes are minutes apart, so the
-runner's slow drift (thermal throttling, frequency scaling, noisy neighbours)
-lands entirely on the feature-vs-baseline axis and shows up as a ±2-5% phantom
-delta — large enough to bury a real 2-4% optimization.
-
-This script consumes the output of the new measurement strategy: R short rounds
-where each round runs the feature binary and the baseline binary back-to-back
-(A B A B ...). Because the two halves of a pair share the same local machine
-state, the per-round paired Δ% cancels the common-mode drift. We then take the
-mean of the R paired Δ% and a seeded bootstrap CI over them, and call a change
-significant ONLY when that CI excludes zero — so a single lucky round can't flip
-the verdict either.
-
-The statistics (median / quantile / seeded bootstrap CI) are ported verbatim
-from ARO's significance gate (aro/stats.py) so the two harnesses share one tested
-implementation.
-
-I/O is via environment variables:
- ROUNDS_DIR directory holding the round files (default ".")
- OUT output markdown path (default "comparison.md")
- FEATURE_SHA feature commit (for the comment header link)
- BASELINE_SHA baseline commit (for the comment header link)
- REPO_URL repository html url (for the commit links)
- BOOTSTRAP_ITERS bootstrap resamples (default 2000)
- AA_CHECK "true" when feature_sha == baseline_sha (A/A self-check)
-
-Round files are named "____r.txt" where phase is "feature"
-or "baseline" and the body is criterion `--output-format bencher` output.
-"""
-from __future__ import annotations
-
-import glob
-import math
-import os
-import random
-import re
-
-# ---------------------------------------------------------------------------
-# Statistics — ported verbatim from ARO (aro/stats.py). stdlib-only,
-# deterministic given the seed so a re-run reproduces the same verdict.
-# ---------------------------------------------------------------------------
-
-
-def median(values) -> float:
- v = sorted(x for x in values if _finite(x))
- n = len(v)
- if n == 0:
- return math.nan
- if n % 2 == 1:
- return v[n // 2]
- return (v[n // 2 - 1] + v[n // 2]) / 2.0
-
-
-def quantile(values, q: float) -> float:
- """Linear-interpolated quantile at q in [0,1]. NaNs dropped."""
- v = sorted(x for x in values if _finite(x))
- n = len(v)
- if n == 0:
- return math.nan
- if n == 1:
- return v[0]
- q = min(max(q, 0.0), 1.0)
- pos = q * (n - 1)
- lo = int(math.floor(pos))
- hi = int(math.ceil(pos))
- if hi >= n:
- hi = n - 1
- if lo == hi:
- return v[lo]
- frac = pos - lo
- return v[lo] + (v[hi] - v[lo]) * frac
-
-
-def seed_for_metric(metric: str) -> int:
- """Stable 64-bit seed per metric (FNV-1a-ish) so each bootstrap is
- reproducible and independent of metric ordering."""
- h = 0xCBF29CE484222325
- for b in metric.encode("utf-8"):
- h ^= b
- h = (h * 0x00000100000001B3) & 0xFFFFFFFFFFFFFFFF
- return h ^ 0x9E3779B97F4A7C15
-
-
-def bootstrap_ci(deltas_pct, iters: int = 2000, seed: int = 0):
- """~95% bootstrap CI (percent) on paired Δ% values; returns (low, high).
-
- Resamples with replacement `iters` times, takes each resample's mean, and
- returns the 2.5th / 97.5th percentiles of those means. Deterministic given
- `seed`. Empty input -> (0.0, 0.0)."""
- if not deltas_pct:
- return (0.0, 0.0)
- if iters == 0:
- m = sum(deltas_pct) / len(deltas_pct)
- return (m, m)
- rng = random.Random(seed)
- n = len(deltas_pct)
- means = []
- for _ in range(iters):
- s = 0.0
- for _ in range(n):
- s += deltas_pct[rng.randrange(n)]
- means.append(s / n)
- means.sort()
- return (quantile(means, 0.025), quantile(means, 0.975))
-
-
-def _finite(x) -> bool:
- try:
- return not (math.isnan(x) or math.isinf(x))
- except TypeError:
- return False
-
-
-# ---------------------------------------------------------------------------
-# Parsing
-# ---------------------------------------------------------------------------
-
-# "test snailtracer/revm_pinned ... bench: 12345 ns/iter (+/- 678)"
-_BENCH_LINE = re.compile(
- r"^test\s+(.+?)\s+\.\.\.\s+bench:\s+([\d,]+)\s+ns/iter\s+\(\+/-\s+([\d,]+)\)"
-)
-# "____r.txt"
-_ROUND_FILE = re.compile(r"^(feature|baseline)__(.+)__r(\d+)\.txt$")
-
-# A change must clear this many usable paired rounds before its bootstrap CI is
-# allowed to claim significance — a CI over 1-2 points is not trustworthy.
-MIN_PAIRS = 3
-
-# Floor clamps, mirrored from ARO's calibrate_floors: never trust a floor below
-# 0.5% (we don't claim to resolve sub-0.5% effects), and fall back to 2.0% when
-# there aren't enough samples to estimate one.
-FLOOR_MIN = 0.5
-FLOOR_FALLBACK = 2.0
-
-
-def parse_bencher(text: str) -> dict:
- out = {}
- for line in text.splitlines():
- m = _BENCH_LINE.match(line)
- if m:
- name = m.group(1).strip()
- ns = float(m.group(2).replace(",", ""))
- out[name] = ns
- return out
-
-
-def load_rounds(rounds_dir: str):
- """Return {phase: {(target, bench_name): {round: ns}}} for phase in
- feature/baseline. The key is (target, bench_name), not bench_name alone: all
- per-target artifacts are downloaded into one directory, so two targets that
- happen to emit the same criterion name would otherwise overwrite each other."""
- data = {"feature": {}, "baseline": {}}
- # Recurse: download-artifact + merge-multiple may place the round files
- # directly under the download root (when upload-artifact collapses the
- # `rounds/` prefix) or one level down — search both so the comparator finds
- # them regardless.
- paths = glob.glob(os.path.join(rounds_dir, "**", "*.txt"), recursive=True)
- for path in sorted(paths):
- fm = _ROUND_FILE.match(os.path.basename(path))
- if not fm:
- continue
- phase, target, rnd = fm.group(1), fm.group(2), int(fm.group(3))
- try:
- with open(path, "r", encoding="utf-8") as fh:
- parsed = parse_bencher(fh.read())
- except OSError:
- continue
- for name, ns in parsed.items():
- data[phase].setdefault((target, name), {})[rnd] = ns
- return data
-
-
-# ---------------------------------------------------------------------------
-# Aggregation
-# ---------------------------------------------------------------------------
-
-
-def noise_floor(series_list) -> float:
- """A/A noise floor (percent) for one bench, computed from the round-to-round
- variation of repeated measurements of the SAME binary — so it costs no extra
- runs. Each phase's per-round values (feature_1..feature_R, baseline_1..R) are
- repeats of one binary; the spread of their relative |Δ%| estimates the
- machine's own jitter. Floor = 90th percentile of those magnitudes, clamped —
- exactly ARO's calibrate_floors, fed from in-band data instead of a separate
- A/A pass.
-
- Compare only rounds of the SAME execution slot. `bench_paired.sh` alternates
- the within-pair order every round, so for each phase the odd and even series
- represent different first-vs-second slots. Consecutive rounds therefore
- straddle the slot boundary and their delta is dominated by the slot-order
- effect (frequency ramp, cold cache) — which the paired *mean* already
- cancels. Pairing within a slot (odd-with-odd, even-with-even) keeps this
- floor measuring the random jitter it is meant to, instead of re-importing the
- slot effect the mean removed and over-suppressing real sub-floor changes.
-
- `series_list` is a list of {round: ns} dicts (one per phase)."""
- mags = []
- for series in series_list:
- for parity in (0, 1):
- vals = [series[r] for r in sorted(series) if r % 2 == parity]
- for a, b in zip(vals, vals[1:]):
- if _finite(a) and _finite(b) and a != 0.0:
- mags.append(abs((b - a) / a * 100.0))
- if len(mags) < 2:
- return FLOOR_FALLBACK
- q90 = quantile(mags, 0.90)
- return max(q90, FLOOR_MIN) if _finite(q90) else FLOOR_FALLBACK
-
-
-class Comparison:
- __slots__ = (
- "target", "name", "n_pairs", "mean_delta", "ci_low", "ci_high", "floor",
- "feature_ns", "baseline_ns", "significant", "noise_limited",
- "regressed", "improved",
- )
-
- def __init__(self, target, name, n_pairs, mean_delta, ci_low, ci_high, floor,
- feature_ns, baseline_ns):
- self.target = target
- self.name = name
- self.n_pairs = n_pairs
- self.mean_delta = mean_delta
- self.ci_low = ci_low
- self.ci_high = ci_high
- self.floor = floor
- self.feature_ns = feature_ns
- self.baseline_ns = baseline_ns
- # ARO's two-part gate: the bootstrap CI must exclude zero (the sign of
- # the effect is resolved) AND the effect must clear the machine's own
- # A/A noise floor (it's bigger than the jitter that produced the CI).
- # Either alone is a known false-positive source — drift fakes a clean CI,
- # and a tiny CI-excluding effect can still be pure measurement noise.
- excludes_zero = (ci_low > 0 and ci_high > 0) or (ci_low < 0 and ci_high < 0)
- enough = n_pairs >= MIN_PAIRS
- self.significant = excludes_zero and enough and abs(mean_delta) > floor
- # CI resolved a direction the floor just can't certify above its jitter.
- self.noise_limited = excludes_zero and enough and not self.significant
- self.regressed = self.significant and mean_delta > 0
- self.improved = self.significant and mean_delta < 0
-
-
-def compare(data, iters: int):
- feature, baseline = data["feature"], data["baseline"]
- keys = sorted(set(feature) & set(baseline)) # (target, bench_name) tuples
- out = []
- for key in keys:
- target, name = key
- frounds, brounds = feature[key], baseline[key]
- deltas, fvals, bvals = [], [], []
- for rnd in sorted(set(frounds) & set(brounds)):
- f, b = frounds[rnd], brounds[rnd]
- if not _finite(f) or not _finite(b) or b == 0.0:
- continue
- deltas.append((f - b) / b * 100.0)
- fvals.append(f)
- bvals.append(b)
- if not deltas:
- continue
- mean_delta = sum(deltas) / len(deltas)
- ci_low, ci_high = bootstrap_ci(deltas, iters, seed_for_metric(f"{target}/{name}"))
- floor = noise_floor([frounds, brounds])
- out.append(Comparison(target, name, len(deltas), mean_delta, ci_low,
- ci_high, floor, median(fvals), median(bvals)))
- return out
-
-
-# ---------------------------------------------------------------------------
-# Baseline-gap section (HEAD only) — unchanged in spirit from the old harness:
-# for every group that contains `revm_pinned`, show how each later row scales
-# relative to it. Uses the feature (HEAD) median time per row.
-# ---------------------------------------------------------------------------
-
-BASELINE_ROW = "revm_pinned"
-ROW_ORDER = [
- "revm_pinned", "revm_latest", "op_revm_pinned", "op_revm_latest",
- "equivalence", "mini_rex", "rex", "rex1", "rex2", "rex3", "rex4", "rex5",
- "rex6", "rex7",
-]
-SPECS = set(ROW_ORDER)
-
-
-def format_time(ns: float) -> str:
- if ns >= 1_000_000:
- return f"{ns / 1_000_000:.2f} ms"
- if ns >= 1_000:
- return f"{ns / 1_000:.2f} µs"
- return f"{ns:.0f} ns"
-
-
-def split_spec(full_name):
- """Split a criterion name into (group, spec). `spec` is the segment naming an
- EVM layer (`revm_pinned`, `rex4`, ...); `group` is the rest of the path. The
- spec is NOT always the last segment: a per-row variant suffix produces
- `//` (e.g. `sstore_heavy/revm_pinned/existing_account_50`),
- so locate the spec by name rather than assuming position — otherwise groups
- with a variant lose their `revm_pinned` row and drop out of the table. Returns
- None when no segment is a spec (not a baseline-comparison bench)."""
- segs = full_name.split("/")
- idx = next((i for i, s in enumerate(segs) if s in SPECS), None)
- if idx is None:
- return None
- group = "/".join(segs[:idx] + segs[idx + 1:])
- return (group, segs[idx]) if group else None
-
-
-def baseline_gap_section(feature) -> str:
- # feature: {(target, bench_name): {round: ns}} → median ns per (target, row).
- groups = {}
- for (target, full_name), rounds in feature.items():
- parsed = split_spec(full_name)
- if parsed is None:
- continue
- group, spec = parsed
- groups.setdefault((target, group), {})[spec] = median(list(rounds.values()))
-
- # Prefix the target only when the same group name came from >1 target, so
- # colliding groups get distinct headers instead of duplicates.
- targets_by_group = {}
- for target, group in groups:
- targets_by_group.setdefault(group, set()).add(target)
-
- out = ""
- for target, group in sorted(groups):
- rows = groups[(target, group)]
- base = rows.get(BASELINE_ROW)
- if base is None:
- continue
- ordered = [r for r in ROW_ORDER if rows.get(r) is not None]
- extras = sorted(r for r in rows if r not in ROW_ORDER)
- title = f"{target}/{group}" if len(targets_by_group[group]) > 1 else group
- out += f"\n### `{title}`\n\n"
- out += "| spec | time | × vs `revm_pinned` |\n"
- out += "|------|------|--------------------|\n"
- for row in ordered + extras:
- ns = rows[row]
- marker = " (baseline)" if row == BASELINE_ROW else ""
- out += f"| `{row}` | {format_time(ns)} | {ns / base:.2f}×{marker} |\n"
-
- # A ROW_ORDER entry that no bench emitted is dropped silently by the filter above, so the
- # table looks complete while a spec is missing from it. That is how `rex6` went unreported
- # after it was added to the bench spec list but not here. Name the gap instead.
- seen = {spec for rows in groups.values() for spec in rows}
- missing = [row for row in ROW_ORDER if row not in seen]
- if missing:
- names = ", ".join(f"`{row}`" for row in missing)
- out += (
- f"\n> No benchmark emitted a row for {names}. "
- f"Either add the spec to `SPEC_IDS` in `crates/mega-evm/benches/common/mod.rs`, "
- f"or drop it from `ROW_ORDER` here.\n"
- )
- return out
-
-
-# ---------------------------------------------------------------------------
-# Rendering
-# ---------------------------------------------------------------------------
-
-
-def icon(c: Comparison) -> str:
- if c.improved:
- return ":rocket:"
- if c.regressed:
- return ":x:" if c.mean_delta > 15 else ":warning:"
- if c.noise_limited:
- return ":eyes:" # directional, but below this machine's noise floor
- return ":white_circle:"
-
-
-def ci_str(c: Comparison) -> str:
- return f"[{c.ci_low:+.1f}%, {c.ci_high:+.1f}%]"
-
-
-def row_str(c: Comparison, label: str) -> str:
- sign = "+" if c.mean_delta > 0 else ""
- return (f"| {label} | {format_time(c.baseline_ns)} | {format_time(c.feature_ns)} "
- f"| {sign}{c.mean_delta:.1f}% | {ci_str(c)} | ±{c.floor:.1f}% | {icon(c)} |")
-
-
-TABLE_HEADER = (
- "| Benchmark | Baseline | Feature | Δ (mean) | 95% CI | A/A floor | |\n"
- "|-----------|----------|---------|----------|--------|-----------|-|\n"
-)
-
-LEGEND = (
- "_:rocket: significant speedup · :x:/:warning: significant regression · "
- ":eyes: directional but below the A/A noise floor · :white_circle: within "
- "noise._\n"
-)
-
-METHODOLOGY = (
- "**Paired, order-interleaved A/B.** Each round runs the feature and "
- "baseline binaries back-to-back on the same runner; the verdict is the "
- "mean of the per-round paired Δ% with a 95% bootstrap CI over the "
- "rounds. A change is flagged only when its **CI excludes 0 _and_ |Δ| "
- "clears the bench's A/A noise floor** (that bench's own round-to-round "
- "jitter), so minutes-apart machine drift no longer reads as a regression "
- "and a real sub-5% change is no longer buried in it.\n\n" + LEGEND
-)
-
-# Lanes that run upstream revm / op-revm, not this repo's EVM code. A PR that
-# doesn't touch the bench harness or vendored dependencies cannot change what
-# these lanes execute — so a significant delta on them measures the
-# binary-layout / link-order difference between the two builds (the relink
-# floor), not the change under review.
-CONTROL_SPECS = {"revm_pinned", "revm_latest", "op_revm_pinned", "op_revm_latest"}
-
-# Significant rows shown expanded; the rest fold into a .
-TOP_SIGNIFICANT = 15
-
-# GitHub caps issue comments at 65536 characters; stay comfortably under it by
-# dropping the bulkiest folded sections (full table first, then baseline gap)
-# instead of failing the post. The raw round files ride in the run artifact
-# either way. Env-overridable so tests can exercise the drop path.
-MAX_COMMENT_CHARS = int(os.environ.get("MAX_COMMENT_CHARS", "60000"))
-
-
-def _is_control(label: str) -> bool:
- return any(seg in CONTROL_SPECS for seg in label.split("/"))
-
-
-def _details(summary: str, inner: str) -> str:
- return f"{summary}\n\n{inner}\n\n\n"
-
-
-def _table(cs, label_of) -> str:
- return TABLE_HEADER + "\n".join(row_str(c, label_of[id(c)]) for c in cs) + "\n"
-
-
-def render(comparisons, feature_rounds, feature_sha, baseline_sha, repo_url,
- aa_check: bool) -> str:
- """One screen tells the verdict; everything long folds into .
-
- Order: header → headline counts → relink-floor hint (when control lanes
- flag) → significant table (worst first, top rows expanded) → folded
- baseline-gap / full-table / methodology sections."""
- body = "## Criterion Benchmark Comparison\n\n"
- body += (
- f"> Comparing [`baseline`]({repo_url}/commit/{baseline_sha})"
- f" → [`feature`]({repo_url}/commit/{feature_sha})\n\n"
- )
-
- if aa_check:
- body += (
- "> :test_tube: **A/A self-check run** — feature and baseline are the "
- "**same commit**. Every row should report ≈0% with a CI that "
- "contains 0; that is the measured noise floor. Any row flagged "
- ":rocket:/:warning:/:x: here is a methodology bug.\n\n"
- )
-
- gap = baseline_gap_section(feature_rounds)
- gap_section = ""
- if gap:
- gap_section = _details(
- "Baseline gap — each EVM layer vs revm_pinned (HEAD only)",
- "_Read the highest `rex*` row present (the latest spec benchmarked) "
- 'for the "user-visible mega gap"; the earlier `rex*` rows are prior '
- "specs. The non-`rex` rows are diagnostic: they show which layer "
- "adds cost._\n" + gap,
- )
-
- if not comparisons:
- body += "_No comparable benchmarks found._\n\n"
- return body + gap_section
-
- comparisons = sorted(comparisons, key=lambda c: (c.name, c.target))
- # Only prefix the target when the same bench name came from more than one
- # target — otherwise two targets that collide on a name would render as two
- # indistinguishable rows. The common (no-collision) case stays unprefixed.
- targets_by_name = {}
- for c in comparisons:
- targets_by_name.setdefault(c.name, set()).add(c.target)
- label_of = {
- id(c): (f"{c.target}/{c.name}" if len(targets_by_name[c.name]) > 1 else c.name)
- for c in comparisons
- }
- regressions = sum(1 for c in comparisons if c.regressed)
- improvements = sum(1 for c in comparisons if c.improved)
- noise_limited = sum(1 for c in comparisons if c.noise_limited)
- significant = [c for c in comparisons if c.significant]
- within = len(comparisons) - len(significant) - noise_limited
- n_rounds = max((c.n_pairs for c in comparisons), default=0)
-
- # The verdict, first — the counts used to sit at the very bottom.
- body += (
- f"**{len(comparisons)} benchmarks · up to {n_rounds} paired rounds** — "
- f"{regressions} :warning: significant regressions · "
- f"{improvements} :rocket: significant improvements · "
- f"{noise_limited} :eyes: noise-limited · "
- f"{within} :white_circle: within noise\n\n"
- )
-
- ctrl = [c for c in significant if _is_control(label_of[id(c)])]
- if ctrl and not aa_check:
- worst = max(ctrl, key=lambda c: abs(c.mean_delta))
- body += (
- f"> :straight_ruler: **Relink-floor hint:** {len(ctrl)} significant "
- f"row(s) sit on upstream control lanes (`revm_*` / `op_revm_*`), "
- f"worst {worst.mean_delta:+.1f}% on `{label_of[id(worst)]}`. Those "
- "lanes do not execute this repo's EVM code — unless the PR touches "
- "the bench harness or vendored dependencies, a significant delta "
- "there measures binary-layout / link-order noise between the two "
- "builds, and same-magnitude findings on mega lanes should be read "
- "against that floor.\n\n"
- )
-
- if significant:
- # Regressions strictly before improvements (each worst-first): ranking
- # by |Δ| alone would let a stack of big speedups push a real +6%
- # regression below the fold — the one row a reviewer must not miss.
- by_impact = sorted(significant,
- key=lambda c: (c.improved, -abs(c.mean_delta)))
- head, tail = by_impact[:TOP_SIGNIFICANT], by_impact[TOP_SIGNIFICANT:]
- body += "### Significant changes (worst first)\n\n"
- body += _table(head, label_of) + "\n"
- if tail:
- body += _details(f"{len(tail)} more significant rows",
- _table(tail, label_of))
- body += LEGEND + "\n"
- else:
- body += (
- "**No significant changes** — no bench cleared both the bootstrap "
- "CI and its A/A noise floor.\n\n"
- )
-
- # Folded bulk, dropped last-first when the comment would blow the size cap:
- # the full table goes before the baseline gap (it is the least-read — the
- # significant rows are already shown and the rounds live in the artifact).
- optional = []
- if gap_section:
- optional.append(("the baseline-gap tables", gap_section))
- optional.append((f"the all-{len(comparisons)}-comparisons table",
- _details(f"All {len(comparisons)} comparisons",
- _table(comparisons, label_of))))
- methodology = _details("Methodology", METHODOLOGY)
- dropped = []
- while optional and (len(body) + sum(len(s) for _, s in optional)
- + len(methodology) > MAX_COMMENT_CHARS):
- dropped.append(optional.pop()[0])
- for _, section in optional:
- body += section
- body += methodology
- if dropped:
- body += (
- f"_Dropped to fit GitHub's comment size limit: "
- f"{', '.join(reversed(dropped))}. The complete data is in the "
- "run's `criterion-benchmark-results` artifact._\n"
- )
- return body
-
-
-def main():
- rounds_dir = os.environ.get("ROUNDS_DIR", ".")
- out_path = os.environ.get("OUT", "comparison.md")
- feature_sha = os.environ.get("FEATURE_SHA", "")
- baseline_sha = os.environ.get("BASELINE_SHA", "")
- repo_url = os.environ.get("REPO_URL", "")
- iters = int(os.environ.get("BOOTSTRAP_ITERS", "2000"))
- aa_check = os.environ.get("AA_CHECK", "").lower() == "true"
-
- data = load_rounds(rounds_dir)
- comparisons = compare(data, iters)
- body = render(comparisons, data["feature"], feature_sha, baseline_sha,
- repo_url, aa_check)
-
- with open(out_path, "w", encoding="utf-8") as fh:
- fh.write(body)
- print(body)
-
-
-if __name__ == "__main__":
- main()
diff --git a/.github/scripts/bench_paired.sh b/.github/scripts/bench_paired.sh
deleted file mode 100755
index 0950adf82..000000000
--- a/.github/scripts/bench_paired.sh
+++ /dev/null
@@ -1,70 +0,0 @@
-#!/usr/bin/env bash
-#
-# Paired, order-interleaved A/B measurement for one bench target.
-#
-# Runs the feature and baseline bench binaries back-to-back for R short rounds,
-# alternating which side goes first each round (A B / B A / A B ...). Keeping the
-# two halves of every pair adjacent in time is the whole point: the runner's slow
-# drift (thermal/frequency/noisy-neighbour) hits both halves equally, so the
-# per-round paired Δ% computed downstream cancels it. The single sequential
-# feature-then-baseline pass it replaces could not — its two halves are minutes
-# apart, turning drift into a ±2-5% phantom delta.
-#
-# Each round uses a deliberately SHORT criterion config; precision is recovered
-# across rounds by the bootstrap CI, not within a round. Per round it writes one
-# `--output-format bencher` file per side, which bench_compare.py then pairs.
-#
-# Usage:
-# bench_paired.sh \
-#
-#
-# may be empty (target absent at the baseline commit) or equal to
-# (the A/A self-check) — both are valid and handled.
-set -euo pipefail
-
-target="$1"
-feature_bin="$2"
-baseline_bin="$3"
-out_dir="$4"
-rounds="$5"
-sample_size="$6"
-warmup="$7"
-measure="$8"
-
-if [ "$rounds" -lt 2 ] || [ $((rounds % 2)) -ne 0 ]; then
- echo "round count must be an even number >= 2 so feature-first and baseline-first slots balance" >&2
- exit 1
-fi
-
-mkdir -p "$out_dir"
-
-run_one() {
- # $1 = binary, $2 = output file
- "$1" --bench --output-format bencher --noplot \
- --sample-size "$sample_size" \
- --warm-up-time "$warmup" \
- --measurement-time "$measure" \
- >"$2"
-}
-
-for r in $(seq 1 "$rounds"); do
- rr=$(printf '%02d' "$r")
- feat_out="${out_dir}/feature__${target}__r${rr}.txt"
- base_out="${out_dir}/baseline__${target}__r${rr}.txt"
-
- # Alternate the within-pair order every round so no side is structurally
- # favoured by always warming the cache / running on a hotter core first.
- # Convention: odd round = feature-first, even round = baseline-first.
- # `bench_compare.py` noise_floor relies on this (same-parity rounds = same
- # execution slot) — keep the two in sync.
- if [ "$baseline_bin" = "" ]; then
- run_one "$feature_bin" "$feat_out" # feature-only (no baseline)
- elif [ $((r % 2)) -eq 1 ]; then
- run_one "$feature_bin" "$feat_out"
- run_one "$baseline_bin" "$base_out"
- else
- run_one "$baseline_bin" "$base_out"
- run_one "$feature_bin" "$feat_out"
- fi
- echo "round ${rr}/${rounds} done for ${target}"
-done
diff --git a/.github/workflows/benchmark.yml b/.github/workflows/benchmark.yml
deleted file mode 100644
index 485b160b7..000000000
--- a/.github/workflows/benchmark.yml
+++ /dev/null
@@ -1,412 +0,0 @@
-name: Criterion Benchmark
-
-on:
- schedule:
- - cron: '0 2 * * 1' # Weekly Monday 2am UTC
- workflow_dispatch:
- inputs:
- aa_check:
- description: 'A/A self-check: compare HEAD against itself to measure the noise floor (no real change should be flagged).'
- type: boolean
- default: false
- issue_comment:
- types: [created]
-
-# The group is suffixed with "is this a real trigger": issue_comment fires for
-# EVERY new comment (codecov, mutation bots, humans chatting), and with a single
-# group + cancel-in-progress an unrelated comment lands in the same group and
-# cancels a live benchmark mid-flight. Non-trigger comment runs now share their
-# own group and only ever cancel each other; real runs still debounce real
-# re-triggers. The suffix mirrors the prepare job's FULL trigger gate
-# (PR-comment + /benchmark + author association) — any comment that would fail
-# the gate must not share a group with real runs, or it cancels a live run it
-# cannot replace (a benchmark-DoS on public PRs); keep the two in sync.
-concurrency:
- group: ${{ github.workflow }}-${{ github.event.issue.number || github.ref }}-${{ github.event_name != 'issue_comment' || (github.event.issue.pull_request && contains(github.event.comment.body, '/benchmark') && contains(fromJSON('["MEMBER","COLLABORATOR","OWNER"]'), github.event.comment.author_association)) }}
- cancel-in-progress: true
-
-# Paired, order-interleaved A/B knobs. The harness runs the feature and baseline
-# bench binaries back-to-back for BENCH_ROUNDS short rounds (A B / B A / ...),
-# then takes the mean of the per-round paired Δ% with a bootstrap CI. Short
-# per-round configs keep the wall-clock close to the old single sequential pass;
-# precision is recovered across rounds, not within one. Tune here.
-env:
- # Keep BENCH_ROUNDS even: the within-pair order alternates each round
- # (feature-first / baseline-first), so an even count runs each side first
- # exactly as often and the order-effect cancels in the mean. An odd count
- # leaves a one-round imbalance that biases even the A/A self-check.
- BENCH_ROUNDS: '16'
- BENCH_SAMPLE_SIZE: '10'
- BENCH_WARMUP: '0.2'
- BENCH_MEAS: '0.5'
- BOOTSTRAP_ITERS: '2000'
-
-# Least privilege by default: only the jobs that post to the PR get write, and
-# the job that compiles + runs untrusted PR code (`bench`) gets read-only — so a
-# malicious PR run with `/benchmark` has no write-scoped token to abuse.
-permissions:
- contents: read
-
-jobs:
- # Resolve the exact commits ONCE, up front. Every bench job then checks out
- # these fixed SHAs, so a push to the PR while the run is queued/in-flight
- # cannot make different jobs measure different code (or mislabel the result).
- prepare:
- name: Resolve commits
- runs-on: blacksmith-2vcpu-ubuntu-2404
- timeout-minutes: 10
- # Reacts to the triggering comment; does not execute PR code.
- # `issues: write` is required to react to the (issue) comment — PR
- # conversation comments live under the issues API; `pull-requests: write`
- # does not cover their reactions.
- permissions:
- contents: read
- issues: write
- pull-requests: write
- if: >-
- github.event_name != 'issue_comment' || (
- github.event.issue.pull_request &&
- contains(github.event.comment.body, '/benchmark') &&
- (github.event.comment.author_association == 'MEMBER' ||
- github.event.comment.author_association == 'COLLABORATOR' ||
- github.event.comment.author_association == 'OWNER')
- )
- outputs:
- feature_sha: ${{ steps.resolve.outputs.feature_sha }}
- baseline_sha: ${{ steps.resolve.outputs.baseline_sha }}
- compare: ${{ steps.resolve.outputs.compare }}
- aa_check: ${{ steps.resolve.outputs.aa_check }}
- steps:
- # Resolve the feature/baseline commits via the API ONLY — no checkout and
- # no fetch of the PR ref. This write-privileged job therefore never brings
- # untrusted PR code (or even a PR-controlled ref) into the workspace; the
- # actual PR code is only ever materialized in the read-only `bench` job.
- - name: Resolve commits and react
- id: resolve
- uses: actions/github-script@v7
- with:
- script: |
- if (context.eventName === 'workflow_dispatch' &&
- context.payload.inputs && context.payload.inputs.aa_check === 'true') {
- // A/A self-check: compare the checked-out commit against ITSELF.
- // A correctly-paired harness must flag nothing — the spread it
- // measures is the pure noise floor.
- core.setOutput('feature_sha', context.sha);
- core.setOutput('baseline_sha', context.sha);
- core.setOutput('compare', 'true');
- core.setOutput('aa_check', 'true');
- return;
- }
- if (context.eventName !== 'issue_comment') {
- // schedule / workflow_dispatch: benchmark the checked-out ref,
- // no baseline comparison.
- core.setOutput('feature_sha', context.sha);
- core.setOutput('baseline_sha', '');
- core.setOutput('compare', 'false');
- core.setOutput('aa_check', 'false');
- return;
- }
- const { owner, repo } = context.repo;
- const pull_number = context.payload.issue.number;
- const pr = await github.rest.pulls.get({ owner, repo, pull_number });
- const featureSha = pr.data.head.sha;
- // GitHub's compare endpoint returns the merge-base of the PR base
- // branch and the PR head — same commit `git merge-base` would pick.
- const cmp = await github.rest.repos.compareCommitsWithBasehead({
- owner,
- repo,
- basehead: `${pr.data.base.ref}...${featureSha}`,
- });
- const baselineSha = cmp.data.merge_base_commit.sha;
- core.setOutput('feature_sha', featureSha);
- core.setOutput('baseline_sha', baselineSha);
- core.setOutput('compare', 'true');
- core.setOutput('aa_check', 'false');
- core.info(`Feature: ${featureSha} Baseline: ${baselineSha}`);
- // Best-effort acknowledgement: the outputs above are already set, so
- // a failed reaction must NOT fail this job (which would skip bench +
- // compare). Swallow any error and carry on.
- try {
- await github.rest.reactions.createForIssueComment({
- owner,
- repo,
- comment_id: context.payload.comment.id,
- content: 'rocket',
- });
- } catch (e) {
- core.warning(`could not add :rocket: reaction: ${e.message}`);
- }
-
- # Claim/refresh THE report comment right away: it names the action run so
- # a watcher knows where the benchmark lives, and the compare job later
- # edits this same comment in place — repeated /benchmark runs never stack
- # a second giant report. Best-effort: a failed post must not skip bench.
- - name: Post in-progress status comment
- if: github.event_name == 'issue_comment'
- continue-on-error: true
- uses: actions/github-script@v7
- env:
- FEATURE_SHA: ${{ steps.resolve.outputs.feature_sha }}
- BASELINE_SHA: ${{ steps.resolve.outputs.baseline_sha }}
- with:
- script: |
- const marker = '';
- const runUrl = `${context.serverUrl}/${context.repo.owner}/${context.repo.repo}/actions/runs/${context.runId}`;
- const short = (s) => (s || '').slice(0, 12);
- const body = [
- marker,
- '## Criterion Benchmark Comparison',
- '',
- `:hourglass_flowing_sand: **Benchmark in progress** — [watch the run](${runUrl})`,
- '',
- `Comparing \`${short(process.env.BASELINE_SHA)}\` (baseline) → ` +
- `\`${short(process.env.FEATURE_SHA)}\` (feature). ` +
- 'This comment is updated in place when the run finishes.',
- ].join('\n');
- const { owner, repo } = context.repo;
- const issue_number = context.payload.issue.number;
- const comments = await github.paginate(github.rest.issues.listComments,
- { owner, repo, issue_number, per_page: 100 });
- const mine = comments.filter(c => c.user && c.user.login === 'github-actions[bot]'
- && c.body && c.body.includes(marker)).pop();
- if (mine) {
- await github.rest.issues.updateComment({ owner, repo, comment_id: mine.id, body });
- } else {
- await github.rest.issues.createComment({ owner, repo, issue_number, body });
- }
-
- # One job per bench target. Each job builds BOTH the feature and baseline bench
- # binaries up front (no rebuild during measurement), then runs them paired and
- # order-interleaved on the SAME runner for BENCH_ROUNDS short rounds. Pairing
- # the two sides inside each round cancels the runner's slow drift, which the
- # old "whole feature suite, then whole baseline suite" pass turned into a
- # ±2-5% phantom delta. Jobs run in parallel across targets.
- bench:
- name: Bench ${{ matrix.target }}
- needs: prepare
- runs-on: blacksmith-32vcpu-ubuntu-2404
- # Paired interleaving runs each round's measurement ~1.5x the old single
- # pass, and re-pays per-bench setup once per round; give heavy-setup targets
- # (block_bench / attack_replay / comp_cost) generous headroom. Lower
- # BENCH_ROUNDS in env to trade back time.
- timeout-minutes: 180
- # This job compiles and runs untrusted PR code — keep it read-only so there
- # is no write-scoped token to exfiltrate. `pull-requests: read` lets
- # `gh pr checkout` resolve the (fork) PR head.
- permissions:
- contents: read
- pull-requests: read
- strategy:
- fail-fast: false
- matrix:
- target: [revm_bench, mega_bench, block_bench, transact, comp_cost, ctt, attack_replay]
- steps:
- - uses: actions/checkout@v4
- with:
- submodules: recursive
- fetch-depth: 0
-
- # Pin the measurement runner to the TRUSTED base-repo version. The initial
- # checkout above is the default branch (for issue_comment events), so this
- # copy is taken before any `git checkout ` swaps in PR code —
- # a PR cannot alter how its own numbers are collected.
- - name: Stash measurement script
- run: |
- mkdir -p "$RUNNER_TEMP/scripts"
- cp .github/scripts/bench_paired.sh "$RUNNER_TEMP/scripts/"
- chmod +x "$RUNNER_TEMP/scripts/bench_paired.sh"
-
- # Fetch the PR head commit by its pull ref, which GitHub keeps in the base
- # repo for fork PRs and even after the source branch is deleted (merged
- # PRs) — unlike `gh pr checkout`, which needs the source branch to exist.
- # `git checkout ` below then resolves against the fetched
- # commit.
- - name: Fetch PR head
- if: github.event_name == 'issue_comment'
- run: git fetch --no-tags origin "pull/${{ github.event.issue.number }}/head"
-
- - name: Install Rust
- uses: actions-rust-lang/setup-rust-toolchain@v1
- with:
- # Empty rustflags overrides this action's default `-D warnings`.
- # Measurement builds should not fail on unrelated warnings; the
- # previous align-all-functions flag is gone (layout stabilization
- # was ineffective), but the opt-out of `-D warnings` stays.
- rustflags: ""
-
- - name: Install Foundry
- uses: foundry-rs/foundry-toolchain@v1
-
- # Build the feature bench binary without running it, capture its path from
- # cargo's JSON output, and copy it out of target/ so a later baseline build
- # (or working-tree checkout) cannot disturb it.
- - name: Build feature bench binary
- run: |
- git checkout --quiet ${{ needs.prepare.outputs.feature_sha }}
- git submodule update --init --recursive
- bin=$(cargo bench --no-run -p mega-evm --bench ${{ matrix.target }} --message-format=json \
- | jq -r 'select(.reason=="compiler-artifact" and .target.name=="${{ matrix.target }}" and (.target.kind|index("bench")) and .executable!=null) | .executable' \
- | tail -1)
- test -n "$bin" || { echo "could not locate feature bench binary"; exit 1; }
- cp "$bin" "$RUNNER_TEMP/feature_bin"
- echo "feature bench binary: $bin"
-
- # Build the baseline binary too (skipped for the A/A self-check, where it
- # is identical, and when the target did not exist at the baseline commit).
- - name: Build baseline bench binary
- if: needs.prepare.outputs.compare == 'true'
- run: |
- if [ "${{ needs.prepare.outputs.aa_check }}" = "true" ]; then
- cp "$RUNNER_TEMP/feature_bin" "$RUNNER_TEMP/baseline_bin"
- echo "A/A self-check: baseline binary = feature binary"
- exit 0
- fi
- git checkout --quiet ${{ needs.prepare.outputs.baseline_sha }}
- git submodule update --init --recursive
- if ! grep -q 'name = "${{ matrix.target }}"' crates/mega-evm/Cargo.toml; then
- echo "target '${{ matrix.target }}' absent at baseline commit — feature-only"
- exit 0
- fi
- bin=$(cargo bench --no-run -p mega-evm --bench ${{ matrix.target }} --message-format=json \
- | jq -r 'select(.reason=="compiler-artifact" and .target.name=="${{ matrix.target }}" and (.target.kind|index("bench")) and .executable!=null) | .executable' \
- | tail -1)
- test -n "$bin" || { echo "could not locate baseline bench binary"; exit 1; }
- cp "$bin" "$RUNNER_TEMP/baseline_bin"
- echo "baseline bench binary: $bin"
-
- # Check out the feature working tree so BOTH prebuilt binaries read the same
- # (PR) fixtures at runtime — a fair comparison on identical inputs.
- - name: Prepare measurement working tree
- run: |
- git checkout --quiet ${{ needs.prepare.outputs.feature_sha }}
- git submodule update --init --recursive
-
- - name: Run paired interleaved benchmark
- if: needs.prepare.outputs.compare == 'true'
- run: |
- mkdir -p rounds
- baseline_bin=""
- [ -f "$RUNNER_TEMP/baseline_bin" ] && baseline_bin="$RUNNER_TEMP/baseline_bin"
- "$RUNNER_TEMP/scripts/bench_paired.sh" \
- "${{ matrix.target }}" \
- "$RUNNER_TEMP/feature_bin" \
- "$baseline_bin" \
- rounds \
- "$BENCH_ROUNDS" "$BENCH_SAMPLE_SIZE" "$BENCH_WARMUP" "$BENCH_MEAS"
-
- # Schedule / dispatch (no comparison): one full-config feature run, kept for
- # the artifact history only — there is no PR to comment on.
- - name: Run standalone benchmark
- if: needs.prepare.outputs.compare != 'true'
- run: |
- "$RUNNER_TEMP/feature_bin" --bench --output-format bencher --noplot \
- | tee "feature_${{ matrix.target }}.txt"
-
- - name: Upload round results
- if: always()
- uses: actions/upload-artifact@v4
- with:
- name: bench-rounds-${{ matrix.target }}
- path: |
- rounds/
- feature_${{ matrix.target }}.txt
- if-no-files-found: ignore
-
- # Join all per-target round files and post the comparison comment. Cheap (no
- # compile, no benches) so it gets a short budget.
- compare:
- name: Compare and comment on PR
- needs: [prepare, bench]
- runs-on: blacksmith-2vcpu-ubuntu-2404
- timeout-minutes: 10
- # `!cancelled()` (NOT `always()`): a failed bench leg still updates the
- # status comment (partial rounds aggregated under a warning banner), but a
- # CANCELLED run must not run compare — the newer run that cancelled it owns
- # the shared comment now, and `always()` would overwrite its fresh
- # "in progress" status with this run's stale partial report.
- if: >-
- ${{ !cancelled() && needs.prepare.result == 'success' &&
- needs.prepare.outputs.compare == 'true' }}
- # Posts the comparison comment; consumes artifacts plus the TRUSTED base-repo
- # aggregation script (checked out below from the default branch, never PR
- # code).
- permissions:
- contents: read
- pull-requests: write
- steps:
- - uses: actions/checkout@v4
- with:
- fetch-depth: 1
-
- - name: Download all round results
- # May find nothing when every bench leg failed; the aggregate step
- # tolerates an empty dir and the comment step banners the failure.
- continue-on-error: true
- uses: actions/download-artifact@v4
- with:
- pattern: bench-rounds-*
- path: all_rounds
- merge-multiple: true
-
- - name: Aggregate rounds into a comparison
- env:
- # Point at the download root; upload-artifact collapses the `rounds/`
- # prefix, so the round files land directly under here. The comparator
- # globs recursively, so a one-level-deeper layout also works.
- ROUNDS_DIR: all_rounds
- OUT: comparison.md
- FEATURE_SHA: ${{ needs.prepare.outputs.feature_sha }}
- BASELINE_SHA: ${{ needs.prepare.outputs.baseline_sha }}
- REPO_URL: ${{ github.event.repository.html_url }}
- AA_CHECK: ${{ needs.prepare.outputs.aa_check }}
- BOOTSTRAP_ITERS: ${{ env.BOOTSTRAP_ITERS }}
- run: |
- mkdir -p all_rounds
- python3 .github/scripts/bench_compare.py
-
- # Update the status comment the prepare job claimed (create if it is
- # somehow missing) — one report comment per PR, edited in place, never a
- # growing stack of giant comments.
- - name: Comment on PR
- if: github.event_name == 'issue_comment'
- uses: actions/github-script@v7
- env:
- BENCH_RESULT: ${{ needs.bench.result }}
- with:
- script: |
- const fs = require('fs');
- const marker = '';
- const runUrl = `${context.serverUrl}/${context.repo.owner}/${context.repo.repo}/actions/runs/${context.runId}`;
- let report;
- try {
- report = fs.readFileSync('comparison.md', 'utf8');
- } catch (e) {
- report = '## Criterion Benchmark Comparison\n\n_No comparison was produced._\n';
- }
- let banner = '';
- if (process.env.BENCH_RESULT !== 'success') {
- banner = `> :warning: **Some bench jobs did not succeed** ` +
- `(bench: \`${process.env.BENCH_RESULT}\`) — results below may be ` +
- `partial; see the [run log](${runUrl}).\n\n`;
- }
- const body = `${marker}\n${banner}${report}\n_Produced by [this run](${runUrl})._`;
- const { owner, repo } = context.repo;
- const issue_number = context.issue.number;
- const comments = await github.paginate(github.rest.issues.listComments,
- { owner, repo, issue_number, per_page: 100 });
- const mine = comments.filter(c => c.user && c.user.login === 'github-actions[bot]'
- && c.body && c.body.includes(marker)).pop();
- if (mine) {
- await github.rest.issues.updateComment({ owner, repo, comment_id: mine.id, body });
- } else {
- await github.rest.issues.createComment({ owner, repo, issue_number, body });
- }
-
- - name: Upload comparison
- if: always()
- uses: actions/upload-artifact@v4
- with:
- name: criterion-benchmark-results
- path: |
- comparison.md
- all_rounds
diff --git a/.github/workflows/build-and-test.yml b/.github/workflows/build-and-test.yml
index fb57502e8..a2136d5be 100644
--- a/.github/workflows/build-and-test.yml
+++ b/.github/workflows/build-and-test.yml
@@ -43,10 +43,82 @@ jobs:
uses: actions-rust-lang/setup-rust-toolchain@v1
- name: Install Foundry
uses: foundry-rs/foundry-toolchain@v1
+ - name: Install cargo-insta
+ uses: taiki-e/install-action@v2
+ with:
+ # The release of the insta version Cargo.lock resolves.
+ tool: cargo-insta@1.47.2
- name: Build
run: cargo build
- name: Run Test
- run: cargo test --workspace
+ # `cargo test --workspace`, run once through cargo-insta. A snapshot that differs fails its
+ # test and nothing is written (--check); a snapshot file no test compared fails the run
+ # (--unreferenced=reject). The last three flags keep cargo test's own behaviour: the
+ # cargo test runner, its per-test output, and stopping at the first failing test binary.
+ # A pending snapshot (`.snap.new`, `.pending-snap`) in the tree is a change nobody
+ # accepted, which the unreferenced check does not look at: it fails the step too.
+ run: |
+ cargo insta test --workspace --check --unreferenced=reject --test-runner cargo-test --no-quiet --fail-fast
+ pending=$(find . -path ./target -prune -o \( -name '*.snap.new' -o -name '*.pending-snap' \) -print)
+ if [ -n "$pending" ]; then
+ echo "::error::pending snapshots in the tree:"
+ echo "$pending"
+ exit 1
+ fi
+
+ test-release:
+ runs-on: ubuntu-24.04
+ timeout-minutes: 60
+ steps:
+ - uses: actions/checkout@v4
+ with:
+ submodules: recursive
+ - name: Install Rust
+ uses: actions-rust-lang/setup-rust-toolchain@v1
+ - name: Install Foundry
+ uses: foundry-rs/foundry-toolchain@v1
+ - name: Run tests in release
+ run: cargo test --workspace --release --locked
+
+ system-contracts:
+ runs-on: ubuntu-24.04
+ timeout-minutes: 10
+ steps:
+ - uses: actions/checkout@v4
+ with:
+ submodules: recursive
+ - name: Install Foundry
+ uses: foundry-rs/foundry-toolchain@v1
+ - name: Run forge tests
+ working-directory: crates/system-contracts
+ run: forge test
+
+ msrv:
+ runs-on: ubuntu-24.04
+ # Sized for a cold cache, which compiles the whole graph, the legacy leg's included, and then
+ # the no_std target.
+ timeout-minutes: 15
+ env:
+ # The workspace's declared `rust-version`; the variable takes precedence over
+ # rust-toolchain.toml, so every cargo call below runs on it.
+ RUSTUP_TOOLCHAIN: "1.94.0"
+ steps:
+ - uses: actions/checkout@v4
+ with:
+ submodules: recursive
+ - name: Install Rust 1.94.0
+ uses: actions-rust-lang/setup-rust-toolchain@v1
+ with:
+ # Installed in place of rust-toolchain.toml's, and set as the directory's override; the
+ # cache is keyed on it, apart from the other jobs'.
+ toolchain: "1.94.0"
+ target: riscv64imac-unknown-none-elf
+ - name: Install Foundry
+ uses: foundry-rs/foundry-toolchain@v1
+ - name: Check the workspace
+ run: cargo check --workspace --all-targets --all-features --locked
+ - name: Check no_std
+ run: cargo check -p mega-evm --target riscv64imac-unknown-none-elf --no-default-features --locked
no-std:
runs-on: ubuntu-24.04
diff --git a/.github/workflows/codspeed.yml b/.github/workflows/codspeed.yml
index 6fe83f1a1..09df2f2ec 100644
--- a/.github/workflows/codspeed.yml
+++ b/.github/workflows/codspeed.yml
@@ -29,11 +29,11 @@ concurrency:
jobs:
codspeed:
name: instruction count
- runs-on: blacksmith-32vcpu-ubuntu-2404
+ runs-on: ubuntu-24.04
# A cold full-suite run measured ~13 min on a GitHub-hosted 4-vCPU runner
# (simulation mode executes each bench once — no criterion sampling loop);
- # the 32vcpu runner only shortens the build — 30 min is ample headroom.
- timeout-minutes: 30
+ # 45 min leaves headroom for a cold build on this runner.
+ timeout-minutes: 45
steps:
- uses: actions/checkout@v4
with:
@@ -46,7 +46,7 @@ jobs:
with:
# Empty rustflags overrides this action's default `-D warnings` —
# measurement builds should not fail on unrelated warnings (clippy CI
- # is the warnings gate). Mirrors benchmark.yml.
+ # is the warnings gate).
rustflags: ""
- name: Install Foundry
uses: foundry-rs/foundry-toolchain@v1
diff --git a/.github/workflows/coverage.yml b/.github/workflows/coverage.yml
index 0298efd37..6b596ed2f 100644
--- a/.github/workflows/coverage.yml
+++ b/.github/workflows/coverage.yml
@@ -21,6 +21,9 @@ jobs:
name: mega-evm core coverage
runs-on: ubuntu-24.04
timeout-minutes: 45
+ permissions:
+ contents: read
+ id-token: write # Codecov upload over OIDC; no token secret
steps:
- uses: actions/checkout@v4
with:
@@ -50,14 +53,25 @@ jobs:
- name: Record Rust version
run: echo "RUST=$(rustc --version)" >> "$GITHUB_ENV"
+ # A failed upload does not fail the job (Codecov being down must not turn every PR red), but
+ # it is reported: the next step warns, so a missing report is seen rather than silent.
- name: Upload coverage to Codecov
+ id: codecov
uses: codecov/codecov-action@v5
+ continue-on-error: true
with:
disable_search: true
- fail_ci_if_error: false
+ fail_ci_if_error: true
files: target/coverage/mega-evm/lcov.info
flags: mega-evm-core
name: mega-evm-core
- token: ${{ secrets.CODECOV_TOKEN }}
+ use_oidc: true
env_vars: RUST
verbose: true
+
+ - name: Warn when the Codecov upload failed
+ if: steps.codecov.outcome == 'failure'
+ run: |
+ echo "::warning title=Codecov upload failed::The coverage report did not reach Codecov, so no coverage comment or status follows. See the upload step's log."
+ echo "> [!WARNING]" >> "$GITHUB_STEP_SUMMARY"
+ echo "> The Codecov upload failed: no coverage comment or status for this run. See the upload step's log." >> "$GITHUB_STEP_SUMMARY"
diff --git a/.github/workflows/exec-spec-satin.yml b/.github/workflows/exec-spec-satin.yml
new file mode 100644
index 000000000..caa593fb0
--- /dev/null
+++ b/.github/workflows/exec-spec-satin.yml
@@ -0,0 +1,440 @@
+name: Execution-spec tests on Satin
+
+# Runs the execution-spec-test state fixtures through MegaEvm with the state-test runner
+# (crates/mega-state-test), on one download of the fixtures:
+#
+# - equivalence mode, a gate: Satin's machinery priced as each fixture fork prices it, on the
+# Osaka entries of the main release and the Amsterdam entries of the glamsterdam devnet
+# release. Every test passes, is skipped for a reason the fork's own runner shares, or fails on
+# a deviation registered in crates/mega-state-test/src/deviations.rs, which lists the exact
+# entries it explains with the hashes Satin produces, and every listed entry fails exactly as
+# listed; the executed and skipped counts are pinned below.
+# - Satin mode, a report: the same entries under Satin's own configuration, counted by outcome
+# in the step summary. It does not fail the job.
+# - the witness replay, a gate: every entry of both fixture releases, in both modes, executed on
+# a recorder of every read and replayed on a strict database and environments that serve
+# exactly a witness (crates/mega-state-test/src/witness.rs). An entry the engine executes
+# replays on the record of every read and on the witness a node builds from its channels; one
+# it rejects, on the record alone. Any entry that fails to replay fails the job.
+# - the blockchain tests, a gate: the Osaka tests of the main release's `blockchain_tests`, imported
+# block by block through Satin's block executor in equivalence mode's configuration (`state-test
+# btest`). Every block's gas used, logs bloom, receipts root and state root are held to its
+# header, and every block the fixture expects to be invalid must be refused for the exception it
+# names. A block that differs passes only when a registered deviation lists that test and block
+# with exactly the outcome Satin produces, and the chain is imported on from Satin's state, so
+# every later block is held too; the summary counts the blocks checked against Ethereum apart
+# from those matched to a deviation. A test passes, deviates as listed, is skipped for a class
+# decided from its content, or fails; the executed and skipped counts are pinned below. The
+# devnet release's blockchain tests are not run: the fork's runner skips them too.
+#
+# The fixture releases are the ones the revm fork's `scripts/run-tests.sh` names at the tag
+# Cargo.lock pins, so this gate and the fork runner's (exec-spec.yml) judge the same fixtures.
+#
+# The `execution-spec gate on Satin` job always runs and reports the gate: it passes when the gate
+# passed, or when a pull request changes nothing the gate covers and the gate did not run. It is
+# the check a branch rule can require; a path filter on the pull request trigger would leave that
+# check pending on every pull request it filters out, so pull requests are filtered by the
+# `changes` job instead.
+
+on:
+ workflow_dispatch:
+ pull_request:
+ push:
+ branches: [satin]
+ paths:
+ - Cargo.lock
+ - Cargo.toml
+ - rust-toolchain.toml
+ - crates/mega-evm/**
+ - crates/mega-state-test/**
+ - crates/state-test/**
+ - crates/system-contracts/**
+ - .github/workflows/exec-spec-satin.yml
+
+permissions:
+ contents: read
+
+concurrency:
+ group: ${{ github.workflow }}-${{ github.ref }}
+ cancel-in-progress: ${{ github.event_name == 'pull_request' }}
+
+jobs:
+ changes:
+ name: changes the gate covers
+ runs-on: ubuntu-24.04
+ timeout-minutes: 10
+ outputs:
+ run: ${{ steps.diff.outputs.run }}
+ steps:
+ - uses: actions/checkout@v4
+ if: github.event_name == 'pull_request'
+ with:
+ # The merge commit and its parents; the first parent is the base it merges into.
+ fetch-depth: 2
+ persist-credentials: false
+
+ - name: Compare the pull request with its base
+ id: diff
+ env:
+ EVENT: ${{ github.event_name }}
+ run: |
+ set -euo pipefail
+ # A push to satin passed the push trigger's path filter, and a manual run asks for the gate.
+ if [ "$EVENT" != pull_request ]; then
+ echo "run=true" >> "$GITHUB_OUTPUT"
+ exit 0
+ fi
+ if ! git rev-parse --verify -q 'HEAD^2' > /dev/null; then
+ echo "::warning::HEAD is not the pull request's merge commit; running the gate"
+ echo "run=true" >> "$GITHUB_OUTPUT"
+ exit 0
+ fi
+ # The paths the push trigger filters on; the two lists stay equal.
+ # Exit 0: nothing covered changed. Exit 1: a covered path changed. Any other exit fails
+ # the step. `--no-renames` counts a file moved out of a covered path as a deletion there.
+ if git diff --quiet --no-renames 'HEAD^1' HEAD -- \
+ Cargo.lock \
+ Cargo.toml \
+ rust-toolchain.toml \
+ 'crates/mega-evm/**' \
+ 'crates/mega-state-test/**' \
+ 'crates/state-test/**' \
+ 'crates/system-contracts/**' \
+ .github/workflows/exec-spec-satin.yml
+ then
+ run=false
+ else
+ status=$?
+ if [ "$status" -ne 1 ]; then
+ echo "::error::git diff exited $status" >&2
+ exit "$status"
+ fi
+ run=true
+ fi
+ echo "the gate runs: $run"
+ echo "run=$run" >> "$GITHUB_OUTPUT"
+
+ exec-spec-satin:
+ name: execution-spec tests on Satin
+ needs: changes
+ if: needs.changes.outputs.run == 'true'
+ runs-on: ubuntu-24.04
+ timeout-minutes: 45
+ env:
+ # Tests equivalence mode executes and skips, per fork, on the pinned fixture releases. The
+ # runner skips what the fork's own runner skips, so these are the counts exec-spec.yml pins
+ # for it. A change that moves the fork pin, and with it the fixtures, updates both, and the
+ # entries the deviations in crates/mega-state-test/src/deviations.rs list.
+ OSAKA_EXECUTED: "19465"
+ OSAKA_SKIPPED: "52"
+ AMSTERDAM_EXECUTED: "15754"
+ AMSTERDAM_SKIPPED: "72"
+ # The Osaka blockchain tests the blockchain gate executes, and those it skips by class. A
+ # change that moves the fixtures updates both, and the blockchain tests the deviations list.
+ BLOCKCHAIN_EXECUTED: "18713"
+ BLOCKCHAIN_SKIPPED: >-
+ withdrawals=62 blob-transactions=2540 requests=174 header-or-body=17
+ undecodable-invalid-transaction=2 create-collision-with-storage=50
+ steps:
+ - uses: actions/checkout@v4
+ with:
+ submodules: recursive
+ persist-credentials: false
+
+ - name: Read the fork pin from Cargo.lock
+ id: pin
+ run: |
+ # A release tag, or a release's commit until its tag is cut.
+ sources=$(grep -oE 'git\+https://github.com/megaeth-labs/revm\?(tag|rev)=[^"#]*#[0-9a-f]*' Cargo.lock | sort -u)
+ if [ "$(printf '%s\n' "$sources" | grep -c .)" -ne 1 ]; then
+ printf 'expected exactly one revm fork revision in Cargo.lock, found:\n%s\n' "$sources" >&2
+ exit 1
+ fi
+ ref=${sources#*=}
+ ref=${ref%%#*}
+ commit=${sources##*#}
+ echo "fork ref $ref at $commit"
+ echo "ref=$ref" >> "$GITHUB_OUTPUT"
+ echo "commit=$commit" >> "$GITHUB_OUTPUT"
+
+ - uses: actions/checkout@v4
+ with:
+ repository: megaeth-labs/revm
+ ref: ${{ steps.pin.outputs.ref }}
+ path: revm-fork
+ sparse-checkout: scripts
+ persist-credentials: false
+
+ - name: Check the ref names the locked revision
+ working-directory: revm-fork
+ env:
+ COMMIT: ${{ steps.pin.outputs.commit }}
+ run: test "$(git rev-parse HEAD)" = "$COMMIT"
+
+ - name: Read the fixture releases the fork's runner downloads
+ id: fixtures
+ run: |
+ set -euo pipefail
+ script=revm-fork/scripts/run-tests.sh
+ # One `NAME="value"` assignment each; a script that no longer has one fails the step
+ # rather than downloading something else.
+ read_var() {
+ local value
+ value=$(sed -n "s/^$1=\"\(.*\)\"$/\1/p" "$script")
+ if [ -z "$value" ] || [ "$(printf '%s\n' "$value" | grep -c .)" -ne 1 ]; then
+ echo "::error::$script: no single $1 assignment" >&2
+ return 1
+ fi
+ printf '%s' "$value"
+ }
+ main_version=$(read_var MAIN_VERSION)
+ devnet_version=$(read_var DEVNET_VERSION)
+ main_url=$(read_var FIXTURES_URL)
+ devnet_url=$(read_var DEVNET_FIXTURES_URL)
+ devnet_tar=$(read_var DEVNET_TAR)
+ # The runner downloads the develop release unless REVM_STATETEST_STABLE is set.
+ grep -q '^ MAIN_TAR="fixtures_develop.tar.gz"$' "$script"
+ main="$main_url/$main_version/fixtures_develop.tar.gz"
+ devnet="$devnet_url/$devnet_version/$devnet_tar"
+ # The directories taken out of each archive: the state tests of both, and the blockchain
+ # tests of the main release.
+ main_dirs="state_tests blockchain_tests"
+ devnet_dirs="state_tests"
+ # The cache is keyed on the archives themselves, and on what is taken out of them:
+ # another name or host at the same version is another download, and a cache that holds
+ # other directories is another cache.
+ archives=$(printf '%s\n%s\n%s\n%s\n' "$main" "$devnet" "$main_dirs" "$devnet_dirs" \
+ | sha256sum | cut -c1-16)
+ {
+ echo "main=$main"
+ echo "devnet=$devnet"
+ echo "main_dirs=$main_dirs"
+ echo "devnet_dirs=$devnet_dirs"
+ echo "key=eest-fixtures-$main_version-$devnet_version-$archives"
+ } >> "$GITHUB_OUTPUT"
+
+ - name: Restore the fixtures
+ id: cache
+ uses: actions/cache@v4
+ with:
+ path: fixtures
+ key: ${{ steps.fixtures.outputs.key }}
+
+ - name: Download the fixtures
+ if: steps.cache.outputs.cache-hit != 'true'
+ env:
+ MAIN_URL: ${{ steps.fixtures.outputs.main }}
+ DEVNET_URL: ${{ steps.fixtures.outputs.devnet }}
+ MAIN_DIRS: ${{ steps.fixtures.outputs.main_dirs }}
+ DEVNET_DIRS: ${{ steps.fixtures.outputs.devnet_dirs }}
+ run: |
+ set -euo pipefail
+ # fetch NAME URL DIRS: the directories DIRS names, out of the archive at URL, under
+ # fixtures/NAME. The archive's top-level `fixtures/` directory is stripped, as the fork's
+ # runner strips it.
+ fetch() {
+ local dir members=()
+ for dir in $3; do members+=("fixtures/$dir"); done
+ mkdir -p "fixtures/$1"
+ curl -fsSL --retry 5 --retry-delay 2 --retry-all-errors "$2" -o "fixtures/$1.tar.gz"
+ tar -xzf "fixtures/$1.tar.gz" --strip-components=1 -C "fixtures/$1" "${members[@]}"
+ rm "fixtures/$1.tar.gz"
+ }
+ fetch main "$MAIN_URL" "$MAIN_DIRS"
+ fetch devnet "$DEVNET_URL" "$DEVNET_DIRS"
+
+ - uses: actions-rust-lang/setup-rust-toolchain@v1
+
+ - uses: foundry-rs/foundry-toolchain@v1
+
+ - name: Build the runner
+ run: cargo build --release --locked -p state-test
+
+ - name: Equivalence mode, the gate
+ run: |
+ set -uo pipefail
+ {
+ echo "### Equivalence mode"
+ echo
+ echo "| Fixtures | Executed | Skipped | Passed | Deviated | Unattributed | Unreproduced |"
+ echo "|---|---:|---:|---:|---:|---:|---:|"
+ } >> "$GITHUB_STEP_SUMMARY"
+ gate() {
+ local fork=$1 dir=$2 executed=$3 skipped=$4 status=0
+ target/release/state-test --fork "$fork" "$dir" \
+ --expect-executed "$executed" --expect-skipped "$skipped" --expect-deviations \
+ --summary-json "equivalence-$fork.json" || status=$?
+ if [ -f "equivalence-$fork.json" ]; then
+ jq -r --arg fork "$fork" '.summary as $s | "| \($fork) | \($s.executed) | \([$s.skipped[]] | add // 0) | \($s.passed) | \([$s.deviated[]] | add // 0) | \($s.unattributed) | \([$s.unreproduced[]] | add // 0) |"' \
+ "equivalence-$fork.json" >> "$GITHUB_STEP_SUMMARY"
+ fi
+ if [ "$status" -ne 0 ]; then
+ echo "::error::equivalence mode failed on the $fork fixtures"
+ fi
+ return "$status"
+ }
+ status=0
+ gate Osaka fixtures/main/state_tests "$OSAKA_EXECUTED" "$OSAKA_SKIPPED" || status=1
+ gate Amsterdam fixtures/devnet/state_tests "$AMSTERDAM_EXECUTED" "$AMSTERDAM_SKIPPED" || status=1
+ exit "$status"
+
+ - name: Satin mode, the report
+ if: ${{ !cancelled() }}
+ continue-on-error: true
+ run: |
+ set -uo pipefail
+ {
+ echo "### Satin mode (a report)"
+ echo
+ echo "| Fixtures | Executed | Skipped | Passed | Failed | Failed by kind |"
+ echo "|---|---:|---:|---:|---:|---|"
+ } >> "$GITHUB_STEP_SUMMARY"
+ status=0
+ for run in "Osaka fixtures/main/state_tests" "Amsterdam fixtures/devnet/state_tests"; do
+ read -r fork dir <<< "$run"
+ target/release/state-test --mode satin --fork "$fork" "$dir" \
+ --summary-json "satin-$fork.json" || status=1
+ if [ -f "satin-$fork.json" ]; then
+ jq -r --arg fork "$fork" '.summary as $s | "| \($fork) | \($s.executed) | \([$s.skipped[]] | add // 0) | \($s.passed) | \([$s.failed[]] | add // 0) | \($s.failed | to_entries | map("\(.key) \(.value)") | join(", ")) |"' \
+ "satin-$fork.json" >> "$GITHUB_STEP_SUMMARY"
+ fi
+ done
+ exit "$status"
+
+ - name: Witness replay over the fixtures, the gate
+ if: ${{ !cancelled() }}
+ run: |
+ set -uo pipefail
+ {
+ echo "### Witness replay"
+ echo
+ echo "| Fixtures | Mode | Replayed on both witnesses | Rejected, replayed on the record alone | Skipped | Failed |"
+ echo "|---|---|---:|---:|---:|---:|"
+ } >> "$GITHUB_STEP_SUMMARY"
+ cargo test --release --locked -p mega-state-test --test witness --no-run || exit 1
+ status=0
+ for run in "Osaka fixtures/main/state_tests" "Amsterdam fixtures/devnet/state_tests"; do
+ read -r fork dir <<< "$run"
+ for mode in equivalence satin; do
+ # The test runs in the package's directory, so the fixtures are named by an absolute path.
+ rc=0
+ MEGA_STATE_TEST_FIXTURES="$GITHUB_WORKSPACE/$dir" MEGA_STATE_TEST_SAMPLE=0 \
+ MEGA_STATE_TEST_FORK="$fork" MEGA_STATE_TEST_MODE="$mode" \
+ cargo test --release --locked -p mega-state-test --test witness -- --ignored --nocapture \
+ 2>&1 | tee "witness-$fork-$mode.log" || rc=$?
+ if [ "$rc" -ne 0 ]; then
+ echo "::error::the witness replay failed on the $fork fixtures in $mode mode"
+ status=1
+ fi
+ # A run passes only on exactly one summary line, in the full format, for this fork and
+ # mode, that executed entries and failed none: a run that tested nothing, or whose
+ # output changed shape, fails the gate rather than passing silently.
+ mapfile -t lines < <(grep '^witness replay of ' "witness-$fork-$mode.log" || true)
+ summary='^witness replay of ([0-9]+) fixture files in ([a-z]+) mode on ([A-Za-z]+): ([0-9]+) executed and replayed on both witnesses, ([0-9]+) rejected and replayed on the database record alone, ([0-9]+) skipped, ([0-9]+) failed$'
+ if [ "${#lines[@]}" -ne 1 ]; then
+ echo "::error::the $fork $mode run printed ${#lines[@]} summary lines, not one"
+ status=1
+ elif ! [[ ${lines[0]} =~ $summary ]]; then
+ echo "::error::the $fork $mode summary is not in the expected format: ${lines[0]}"
+ status=1
+ elif [ "${BASH_REMATCH[3]}" != "$fork" ] || [ "${BASH_REMATCH[2]}" != "$mode" ]; then
+ echo "::error::the $fork $mode run reported ${BASH_REMATCH[3]} in ${BASH_REMATCH[2]} mode"
+ status=1
+ elif [ "${BASH_REMATCH[1]}" -eq 0 ] || [ "${BASH_REMATCH[4]}" -eq 0 ]; then
+ echo "::error::the $fork $mode run executed nothing: ${lines[0]}"
+ status=1
+ elif [ "${BASH_REMATCH[7]}" -ne 0 ]; then
+ echo "::error::the $fork $mode run failed ${BASH_REMATCH[7]} entries"
+ status=1
+ else
+ echo "| $fork | $mode | ${BASH_REMATCH[4]} | ${BASH_REMATCH[5]} | ${BASH_REMATCH[6]} | ${BASH_REMATCH[7]} |" \
+ >> "$GITHUB_STEP_SUMMARY"
+ fi
+ done
+ done
+ exit "$status"
+
+ - name: Blockchain tests through the block executor, the gate
+ if: ${{ !cancelled() }}
+ run: |
+ set -uo pipefail
+ {
+ echo "### Blockchain tests"
+ echo
+ echo "| Fixtures | Executed | Skipped | Passed | Deviated | Unattributed | Unreproduced | Blocks checked against Ethereum | Blocks matched to a deviation |"
+ echo "|---|---:|---:|---:|---:|---:|---:|---:|---:|"
+ } >> "$GITHUB_STEP_SUMMARY"
+ pins=()
+ for pin in $BLOCKCHAIN_SKIPPED; do pins+=(--expect-skipped "$pin"); done
+ rm -f blockchain-Osaka.json
+ status=0
+ target/release/state-test btest fixtures/main/blockchain_tests \
+ --expect-executed "$BLOCKCHAIN_EXECUTED" "${pins[@]}" --expect-deviations \
+ --summary-json blockchain-Osaka.json || status=$?
+ if [ "$status" -ne 0 ]; then
+ echo "::error::the blockchain tests failed the gate"
+ fi
+ # The gate passes only on a summary in the expected shape, for the Osaka blockchain tests,
+ # that executed tests and has no failed test (no block differing from its header without
+ # the exact outcome a registered deviation lists for it), no unread fixture and no listed
+ # test that did not deviate as listed: a run that tested nothing, or whose summary changed
+ # shape, fails the gate rather than passing silently.
+ shape='.suite == "blockchain" and .fork == "Osaka" and (.skip_reasons | type) == "object"
+ and (.summary | (.executed | type) == "number" and (.passed | type) == "number"
+ and (.unattributed | type) == "number" and (.file_failures | type) == "number"
+ and (.skipped | type) == "object" and (.deviated | type) == "object"
+ and (.unreproduced | type) == "object" and (.blocks.matched | type) == "number"
+ and (.blocks.refused | type) == "number" and (.blocks.deviated | type) == "number")'
+ if [ ! -f blockchain-Osaka.json ]; then
+ echo "::error::the blockchain tests wrote no summary"
+ status=1
+ elif ! jq -e "$shape" blockchain-Osaka.json > /dev/null 2>&1; then
+ echo "::error::the blockchain tests' summary is not in the expected shape"
+ status=1
+ elif ! jq -e '.summary.executed > 0' blockchain-Osaka.json > /dev/null; then
+ echo "::error::the blockchain tests executed nothing"
+ status=1
+ elif ! jq -e '.summary | .unattributed == 0 and .file_failures == 0 and (.unreproduced | add // 0) == 0' \
+ blockchain-Osaka.json > /dev/null; then
+ echo "::error::the blockchain tests have a failed test, an unread fixture or a listed test that did not deviate as listed"
+ status=1
+ else
+ jq -r '.summary as $s | "| Osaka | \($s.executed) | \([$s.skipped[]] | add // 0) | \($s.passed) | \([$s.deviated[]] | add // 0) | \($s.unattributed) | \([$s.unreproduced[]] | add // 0) | \($s.blocks.matched + $s.blocks.refused) | \($s.blocks.deviated) |"' \
+ blockchain-Osaka.json >> "$GITHUB_STEP_SUMMARY"
+ {
+ echo
+ echo "| Skipped for | Tests | Why |"
+ echo "|---|---:|---|"
+ jq -r '.summary.skipped as $s | .skip_reasons | to_entries[] | "| \(.key) | \($s[.key] // 0) | \(.value) |"' \
+ blockchain-Osaka.json
+ } >> "$GITHUB_STEP_SUMMARY"
+ fi
+ exit "$status"
+
+ gate:
+ name: execution-spec gate on Satin
+ needs: [changes, exec-spec-satin]
+ # Always, a cancelled run included: a required check that is skipped counts as passed.
+ if: ${{ always() }}
+ runs-on: ubuntu-24.04
+ timeout-minutes: 5
+ steps:
+ - name: Report the gate's outcome
+ env:
+ CHANGES: ${{ needs.changes.result }}
+ RUN: ${{ needs.changes.outputs.run }}
+ GATE: ${{ needs.exec-spec-satin.result }}
+ run: |
+ if [ "$CHANGES" != success ]; then
+ echo "::error::could not tell whether the gate had to run: the changes job ended $CHANGES"
+ exit 1
+ fi
+ if [ "$RUN" != true ]; then
+ echo "nothing the gate covers changed; the gate did not run"
+ exit 0
+ fi
+ if [ "$GATE" != success ]; then
+ echo "::error::the gate ended $GATE"
+ exit 1
+ fi
+ echo "the gate passed"
diff --git a/.github/workflows/exec-spec.yml b/.github/workflows/exec-spec.yml
new file mode 100644
index 000000000..0f9c545b1
--- /dev/null
+++ b/.github/workflows/exec-spec.yml
@@ -0,0 +1,169 @@
+name: Execution-spec tests
+
+# Runs the execution-spec-test fixtures with the revm fork's own runner (`scripts/run-tests.sh`,
+# release mode) at the fork tag Cargo.lock pins, then counts the state tests the runner executes
+# and skips for Osaka (the main fixtures) and Amsterdam (the glamsterdam devnet fixtures) and
+# checks them against the numbers pinned below.
+#
+# It checks the fork MegaEvm runs on, not MegaEvm; exec-spec-satin.yml runs the same fixture
+# releases through MegaEvm. Not a required check.
+
+on:
+ workflow_dispatch:
+ # GitHub fires a schedule only from the default branch's copy of a workflow: this one runs
+ # weekly once `satin` is the default branch. Until then, dispatch it by hand on `satin`.
+ schedule:
+ - cron: "0 4 * * 1" # Weekly, Monday 4:00 UTC
+ # Engine source is not a path here. This job runs the revm fork's own runner
+ # at the revision Cargo.lock pins, so a change to the engine cannot move its
+ # result. exec-spec-satin.yml runs when the engine changes.
+ pull_request:
+ paths:
+ - Cargo.lock
+ - Cargo.toml
+ - .github/workflows/exec-spec.yml
+ push:
+ branches: [satin]
+ paths:
+ - Cargo.lock
+ - Cargo.toml
+ - .github/workflows/exec-spec.yml
+
+permissions:
+ contents: read
+
+concurrency:
+ group: ${{ github.workflow }}-${{ github.ref }}
+ cancel-in-progress: ${{ github.event_name == 'pull_request' }}
+
+jobs:
+ exec-spec:
+ name: execution-spec tests
+ runs-on: ubuntu-24.04
+ timeout-minutes: 60
+ env:
+ # State tests the runner executes and skips, per fork, on the fixture releases
+ # `scripts/run-tests.sh` downloads at the pinned tag (main v5.4.0 develop fixtures,
+ # glamsterdam devnet v8.1.0). The skipped ones are the create-collision fixtures with
+ # storage the runner skips by name, and expected-exception transactions it cannot build
+ # (bad signatures, blob-hash creates). A change that moves the fork pin, and with it the
+ # runner or the fixtures, updates them.
+ OSAKA_EXECUTED: "19465"
+ OSAKA_SKIPPED: "52"
+ AMSTERDAM_EXECUTED: "15754"
+ AMSTERDAM_SKIPPED: "72"
+ steps:
+ - uses: actions/checkout@v4
+ with:
+ persist-credentials: false
+
+ - name: Read the fork pin from Cargo.lock
+ id: pin
+ run: |
+ # A release tag, or a release's commit until its tag is cut.
+ sources=$(grep -oE 'git\+https://github.com/megaeth-labs/revm\?(tag|rev)=[^"#]*#[0-9a-f]*' Cargo.lock | sort -u)
+ if [ "$(printf '%s\n' "$sources" | grep -c .)" -ne 1 ]; then
+ printf 'expected exactly one revm fork revision in Cargo.lock, found:\n%s\n' "$sources" >&2
+ exit 1
+ fi
+ ref=${sources#*=}
+ ref=${ref%%#*}
+ commit=${sources##*#}
+ echo "fork ref $ref at $commit"
+ echo "ref=$ref" >> "$GITHUB_OUTPUT"
+ echo "commit=$commit" >> "$GITHUB_OUTPUT"
+
+ - uses: actions/checkout@v4
+ with:
+ repository: megaeth-labs/revm
+ ref: ${{ steps.pin.outputs.ref }}
+ path: revm-fork
+ persist-credentials: false
+
+ - name: Check the ref names the locked revision
+ working-directory: revm-fork
+ env:
+ COMMIT: ${{ steps.pin.outputs.commit }}
+ run: test "$(git rev-parse HEAD)" = "$COMMIT"
+
+ - name: Read the fork's toolchain
+ id: rust
+ working-directory: revm-fork
+ run: echo "channel=$(sed -n 's/^channel = "\(.*\)"$/\1/p' rust-toolchain.toml)" >> "$GITHUB_OUTPUT"
+
+ - uses: dtolnay/rust-toolchain@master
+ with:
+ toolchain: ${{ steps.rust.outputs.channel }}
+
+ - uses: Swatinem/rust-cache@v2
+ with:
+ workspaces: revm-fork
+ cache-on-failure: true
+
+ - name: Run the fork's execution-spec suites
+ working-directory: revm-fork
+ run: ./scripts/run-tests.sh clean cargo release
+
+ - name: Count the Osaka and Amsterdam state tests
+ working-directory: revm-fork
+ run: |
+ set -euo pipefail
+ # State tests a fixture tree defines for a fork: one per post-state entry, keyed by the
+ # fixtures' fork name (`Osaka`). `$fork` in the jq program is a jq variable.
+ # shellcheck disable=SC2016
+ defined() {
+ find "$1" -name '*.json' -print0 \
+ | xargs -0 jq -r --arg fork "$2" '[.[] | .post[$fork] // [] | length] | add // 0' \
+ | awk '{ n += $1 } END { print n + 0 }'
+ }
+ # The script's run prints no counts, so the two state-test trees run once more with the
+ # runner's per-test JSON outcome on stderr (about a minute of the job). The build is
+ # the one the script made.
+ outcomes() {
+ cargo run --release -p revme -- statetest --json-outcome --omit-progress "$1" \
+ 2> outcomes.jsonl > /dev/null
+ }
+ # State tests the runner executed for a fork, keyed by revm's spec id (`OSAKA`). Other
+ # stderr lines are not JSON and are dropped. `$spec` in the jq program is a jq variable.
+ # shellcheck disable=SC2016
+ executed() {
+ jq -Rr --arg spec "$1" 'fromjson? | select(type == "object" and .fork == $spec) | .test' \
+ outcomes.jsonl | wc -l | tr -d ' '
+ }
+ check() {
+ local label=$1 dir=$2 fork=$3 spec=$4 want_executed=$5 want_skipped=$6
+ local total ran skipped
+ # `check` runs under `||`, where errexit is off, so every step is guarded here: a
+ # counting pipeline that prints the expected number and then fails would otherwise
+ # pass the comparison below. Each command substitution is assigned on its own so the
+ # assignment carries the command's status (`local total=$(...)` would mask it).
+ if ! total=$(defined "$dir" "$fork"); then
+ echo "::error::$label: counting the state tests $dir defines failed"
+ return 1
+ fi
+ if ! outcomes "$dir"; then
+ echo "::error::$label: the runner failed on $dir"
+ return 1
+ fi
+ if ! ran=$(executed "$spec"); then
+ echo "::error::$label: counting the state tests the runner executed for $spec failed"
+ return 1
+ fi
+ skipped=$((total - ran))
+ echo "$label: $ran executed, $skipped skipped of $total defined ($dir)"
+ echo "| $label | $ran | $skipped | $total |" >> "$GITHUB_STEP_SUMMARY"
+ if [ "$ran" != "$want_executed" ] || [ "$skipped" != "$want_skipped" ]; then
+ echo "::error::$label: expected $want_executed executed and $want_skipped skipped, got $ran and $skipped"
+ return 1
+ fi
+ }
+ {
+ echo "| Fixtures | Executed | Skipped | Defined |"
+ echo "|---|---:|---:|---:|"
+ } >> "$GITHUB_STEP_SUMMARY"
+ status=0
+ check Osaka test-fixtures/main/develop/state_tests Osaka OSAKA \
+ "$OSAKA_EXECUTED" "$OSAKA_SKIPPED" || status=1
+ check Amsterdam test-fixtures/devnet/state_tests Amsterdam AMSTERDAM \
+ "$AMSTERDAM_EXECUTED" "$AMSTERDAM_SKIPPED" || status=1
+ exit "$status"
diff --git a/.github/workflows/fuzz.yml b/.github/workflows/fuzz.yml
new file mode 100644
index 000000000..fa1492af1
--- /dev/null
+++ b/.github/workflows/fuzz.yml
@@ -0,0 +1,126 @@
+name: Randomized tests, long mode
+
+# Runs the randomized tests of the Satin engine (crates/mega-evm/tests/fuzz) in their long mode:
+# many more cases per property than the bounded run every pull request makes, drawn from a seed
+# this run chooses (or the one given), in a debug build, where every debug assertion runs, and in
+# a release build, where none does. A failure prints the seed and the case count that reproduce it
+# and the minimal case it shrank to; the job's log is the record.
+#
+# It also runs the byte-price record at two prices and compares them: where a case followed the
+# same path at both, its state gas must not fall as the cost per state byte rises, nor its history
+# gas as the cost per history byte rises (scripts/fuzz_price_monotonic.py).
+#
+# Dispatch only: a scheduled trigger fires on the default branch alone, which the Satin
+# integration branch is not. Dispatch it from the branch to test, with a seed to reproduce a run
+# or none to draw a new one.
+#
+# The two inputs, and how they meet the long mode:
+#
+# - `cases` empty (the default): each property runs fifty times its own bounded count, 6,400 to
+# 38,400 cases, which is what `MEGA_FUZZ_LONG=1` means on its own.
+# - `cases` set: every property runs exactly that many cases. The count replaces the bounded count
+# and the multiplier alike; it is not multiplied by fifty.
+# - `seed` empty: the run draws one seed from the clock, prints it, and uses it for every property
+# and both profiles, so one number reproduces the run.
+#
+# The runner itself reads an empty `MEGA_FUZZ_CASES` or `MEGA_FUZZ_SEED` as unset, so an input left
+# empty cannot fail the run.
+
+on:
+ workflow_dispatch:
+ inputs:
+ cases:
+ description: "Cases per property, exactly; empty runs each at fifty times its bounded count"
+ required: false
+ default: ""
+ seed:
+ description: "The seed to draw the cases from; empty draws one from the clock"
+ required: false
+ default: ""
+
+permissions:
+ contents: read
+
+jobs:
+ seed:
+ name: the run's seed
+ runs-on: ubuntu-24.04
+ timeout-minutes: 5
+ outputs:
+ seed: ${{ steps.seed.outputs.seed }}
+ steps:
+ - name: Take the seed given, or draw one
+ id: seed
+ env:
+ GIVEN: ${{ inputs.seed }}
+ run: |
+ seed="$GIVEN"
+ [ -n "$seed" ] || seed="$(date +%s)"
+ echo "seed=$seed" >> "$GITHUB_OUTPUT"
+ echo "Seed \`$seed\`: reproduce with \`MEGA_FUZZ_SEED=$seed\` and the case count each property prints." >> "$GITHUB_STEP_SUMMARY"
+
+ long:
+ name: long mode (${{ matrix.profile }})
+ needs: seed
+ runs-on: ubuntu-24.04
+ timeout-minutes: 120
+ strategy:
+ fail-fast: false
+ matrix:
+ profile: [debug, release]
+ steps:
+ - uses: actions/checkout@v4
+ with:
+ submodules: recursive
+
+ - name: Install Rust
+ uses: actions-rust-lang/setup-rust-toolchain@v1
+
+ - name: Install Foundry
+ uses: foundry-rs/foundry-toolchain@v1
+
+ - name: Run the properties
+ env:
+ MEGA_FUZZ_LONG: "1"
+ # Empty unless the dispatch named a count, and then every property runs exactly it.
+ MEGA_FUZZ_CASES: ${{ inputs.cases }}
+ MEGA_FUZZ_SEED: ${{ needs.seed.outputs.seed }}
+ run: |
+ if [ "${{ matrix.profile }}" = "release" ]; then
+ cargo test --release --locked -p mega-evm --test fuzz -- --nocapture
+ else
+ cargo test --locked -p mega-evm --test fuzz -- --nocapture
+ fi
+
+ price-monotonicity:
+ name: state and history gas along the byte prices
+ needs: seed
+ runs-on: ubuntu-24.04
+ timeout-minutes: 60
+ steps:
+ - uses: actions/checkout@v4
+ with:
+ submodules: recursive
+
+ - name: Install Rust
+ uses: actions-rust-lang/setup-rust-toolchain@v1
+
+ - name: Install Foundry
+ uses: foundry-rs/foundry-toolchain@v1
+
+ # Both records are drawn from the same seed and the same case count, so the cases match by
+ # index: the long mode's count unless the dispatch named one.
+ - name: Record the cases at the constants and at dearer bytes
+ env:
+ MEGA_FUZZ_LONG: "1"
+ MEGA_FUZZ_CASES: ${{ inputs.cases }}
+ MEGA_FUZZ_SEED: ${{ needs.seed.outputs.seed }}
+ run: |
+ cargo test --release --locked -p mega-evm --features satin-price-override,test-utils --test fuzz --no-run
+ MEGA_FUZZ_PRICE_RECORD="$PWD/target/price-low.txt" \
+ cargo test --release --locked -p mega-evm --features satin-price-override,test-utils --test fuzz -- price_record
+ MEGA_SATIN_CPSB=2000 MEGA_SATIN_CPHB=100 MEGA_FUZZ_PRICE_RECORD="$PWD/target/price-high.txt" \
+ cargo test --release --locked -p mega-evm --features satin-price-override,test-utils --test fuzz -- price_record
+
+ - name: Compare the records
+ run: python3 scripts/fuzz_price_monotonic.py target/price-low.txt target/price-high.txt
diff --git a/.github/workflows/mutation.yml b/.github/workflows/mutation.yml
index 0452f28e7..520a81851 100644
--- a/.github/workflows/mutation.yml
+++ b/.github/workflows/mutation.yml
@@ -1,19 +1,24 @@
name: Mutation Testing
-# All mutation-testing CI lives here. Three concerns, one file:
+# All mutation-testing CI lives here. Four concerns, one file:
# * cargo-mutants gate — generic operators (diff-scoped on PRs, full nightly)
-# * spec-gate — universalmutator + comby custom operators for
-# backward-compat spec gates (diff PR + nightly sweep)
+# * infrastructure gate — the same operators on the code that implements the
+# test gates, which the production scope excludes
# * suppression hygiene — flag suppressions that no longer match a live mutant
-# All three share the scorer scripts/mutation_gate.py. See mutants/README.md.
+# * gate self-test — the scorer's and the driver's own tests
+# The cargo-mutants and infrastructure gates share the scorer
+# scripts/mutation_gate.py.
+# The spec-gate operator pack stays on disk. A single-spec engine has no spec
+# gate for it to mutate, so this workflow does not run it. Suppression hygiene
+# still plans the pack and accepts an empty plan. See mutants/README.md.
on:
workflow_dispatch:
pull_request:
schedule:
# Nightly: full-crate cargo-mutants re-verify (the diff gate never mutates
- # #[cfg(test)] code, so the in-repo killing tests are only re-checked here),
- # the full spec-gate sweep, and the suppression-hygiene check.
+ # #[cfg(test)] code, so the in-repo killing tests are only re-checked here)
+ # and the suppression-hygiene check.
- cron: "0 3 * * *"
concurrency:
@@ -65,6 +70,8 @@ jobs:
# On a PR: mutate only the changed lines (fast gate). On manual dispatch
# there is no PR base, so run the whole crate as an on-demand baseline
# instead of feeding an empty base into `diff` mode (which would fail).
+ # The driver re-runs a mutant that timed out once, alone, into
+ # target/mutants/recheck; the gate takes that outcome for it.
run: |
if [ "${{ github.event_name }}" = "pull_request" ]; then
scripts/mutation_test.sh diff "${{ github.event.pull_request.base.sha }}"
@@ -76,6 +83,7 @@ jobs:
run: |
python3 scripts/mutation_gate.py report \
--results target/mutants/mutants.out \
+ --recheck target/mutants/recheck/mutants.out \
--suppressions mutants/suppressions.toml \
--comment mutation-report.md \
--summary "$GITHUB_STEP_SUMMARY"
@@ -93,7 +101,7 @@ jobs:
try {
body = fs.readFileSync('mutation-report.md', 'utf8');
} catch {
- body = '## 🧬 Mutation testing\n\nNo report produced (no mega-evm changes to mutate).';
+ body = '## 🧬 Mutation testing\n\nNo report produced: the mutation run failed before the gate scored it. See the job log.';
}
const marker = '';
body = `${marker}\n${body}`;
@@ -121,151 +129,99 @@ jobs:
name: mutation-results
path: |
target/mutants/mutants.out
+ target/mutants/recheck/mutants.out
target/mutants.diff
+ target/mutants.log
+ target/mutants/recheck.log
mutation-report.md
if-no-files-found: ignore
- # ── spec-gate: diff-scoped blocking gate on PRs ────────────────────────────
- # Only files+lines the PR changed are mutated, so most PRs generate zero
- # spec-gate mutants and this is near-instant.
- spec-gate:
- name: diff-scoped spec-gate
- if: github.event_name == 'pull_request'
+ # ── cargo-mutants: the test gates' own infrastructure ──────────────────────
+ # The second mutation scope (.cargo/mutants-infra.toml): the scenario runner's
+ # transaction conversion and execute/commit loop. The production scope
+ # excludes test helpers as noise, so this executable logic is never mutated
+ # there. 39 mutants today, so the whole set runs rather than a diff
+ # slice. Informational: it is not a required check.
+ infra-mutants:
+ name: cargo-mutants infrastructure
+ needs: changes
+ # Always on nightly/dispatch; on PRs only when the mutated code, its
+ # configuration or the driver changed.
+ if: |
+ always() &&
+ (github.event_name != 'pull_request' || needs.changes.outputs.infra == 'true')
runs-on: ubuntu-24.04
- timeout-minutes: 60
+ timeout-minutes: 90
steps:
- uses: actions/checkout@v4
with:
submodules: recursive
- fetch-depth: 0 # need base history for the diff
+
- name: Install Rust
uses: actions-rust-lang/setup-rust-toolchain@v1
+
- name: Install Foundry
uses: foundry-rs/foundry-toolchain@v1
+
- name: Install cargo-nextest
uses: taiki-e/install-action@nextest
- - name: Install universalmutator (mise)
- uses: jdx/mise-action@v2
- - name: Install comby
- # Pin the version (reproducible mutant generation). The prebuilt links
- # against libev/libpcre, which are not on the runner by default.
- run: |
- sudo apt-get update
- sudo apt-get install -y libpcre3 libev4
- sudo curl -fsSL https://github.com/comby-tools/comby/releases/download/1.8.1/comby-1.8.1-x86_64-linux -o /usr/local/bin/comby
- sudo chmod +x /usr/local/bin/comby
- comby -version
- - name: Run diff-scoped spec-gate mutation
- run: |
- python3 scripts/umutate.py run --packs spec-gate \
- --diff "${{ github.event.pull_request.base.sha }}" \
- --output target/umutate
+
+ - name: Install cargo-mutants
+ uses: taiki-e/install-action@v2
+ with:
+ tool: cargo-mutants@27.1.0
+
+ - name: Warm build cache
+ run: cargo nextest run -p mega-evm --all-features --no-run
+
+ - name: Run mutation testing
+ env:
+ OUT_DIR: target/mutants-infra
+ run: scripts/mutation_test.sh infra
+
- name: Score and gate
run: |
python3 scripts/mutation_gate.py report \
- --results target/umutate \
+ --results target/mutants-infra/mutants.out \
+ --recheck target/mutants-infra/recheck/mutants.out \
--suppressions mutants/suppressions.toml \
- --comment spec-gate-report.md \
--summary "$GITHUB_STEP_SUMMARY"
- - name: Upsert PR comment
- if: always() && github.event_name == 'pull_request'
- continue-on-error: true
- uses: actions/github-script@v7
- with:
- script: |
- const fs = require('fs');
- let body;
- try {
- body = fs.readFileSync('spec-gate-report.md', 'utf8');
- } catch {
- body = '## 🧬 Spec-gate mutation\n\nNo report produced.';
- }
- const marker = '';
- body = `${marker}\n${body}`;
- const { data: comments } = await github.rest.issues.listComments({
- owner: context.repo.owner, repo: context.repo.repo,
- issue_number: context.issue.number, per_page: 100,
- });
- const existing = comments.find(c => c.body.includes(marker));
- if (existing) {
- await github.rest.issues.updateComment({
- owner: context.repo.owner, repo: context.repo.repo,
- comment_id: existing.id, body,
- });
- } else {
- await github.rest.issues.createComment({
- owner: context.repo.owner, repo: context.repo.repo,
- issue_number: context.issue.number, body,
- });
- }
- - name: Upload artifacts
+
+ - name: Upload mutation artifacts
if: always()
uses: actions/upload-artifact@v4
with:
- name: spec-gate-mutation-diff
+ name: mutation-results-infra
path: |
- target/umutate
- spec-gate-report.md
+ target/mutants-infra/mutants.out
+ target/mutants-infra/recheck/mutants.out
+ target/mutants-infra.log
+ target/mutants-infra/recheck.log
if-no-files-found: ignore
- # ── spec-gate: nightly full sweep, sharded by subsystem ────────────────────
- # Each shard stays bounded (analyze is sequential). Informational: surfaces
- # survivors but does not fail the workflow — triage into suppressions or tests.
- spec-gate-sweep:
- name: spec-gate sweep (${{ matrix.subsystem }})
- if: github.event_name != 'pull_request'
+ # ── gate self-test: the scorer's and the driver's own tests ────────────────
+ # The gate reads a run fail-closed; its tests hold every way a run can leave
+ # results that say nothing to a failure, and the driver's refusal of an old
+ # bash. Seconds long, so it runs on every PR.
+ gate-selftest:
+ name: mutation gate self-test
runs-on: ubuntu-24.04
- timeout-minutes: 330
- strategy:
- fail-fast: false
- matrix:
- subsystem: [evm, limit, block, access, external, system, sandbox]
+ timeout-minutes: 10
steps:
- uses: actions/checkout@v4
- with:
- submodules: recursive
- - name: Install Rust
- uses: actions-rust-lang/setup-rust-toolchain@v1
- - name: Install Foundry
- uses: foundry-rs/foundry-toolchain@v1
- - name: Install cargo-nextest
- uses: taiki-e/install-action@nextest
- - name: Install universalmutator (mise)
- uses: jdx/mise-action@v2
- - name: Install comby
- run: |
- sudo apt-get update
- sudo apt-get install -y libpcre3 libev4
- sudo curl -fsSL https://github.com/comby-tools/comby/releases/download/1.8.1/comby-1.8.1-x86_64-linux -o /usr/local/bin/comby
- sudo chmod +x /usr/local/bin/comby
- comby -version
- - name: Run spec-gate mutation (${{ matrix.subsystem }})
- run: |
- python3 scripts/umutate.py run --packs spec-gate \
- --files "crates/mega-evm/src/${{ matrix.subsystem }}/*" \
- --output "target/umutate/${{ matrix.subsystem }}"
- - name: Score (informational)
- run: |
- python3 scripts/mutation_gate.py report \
- --results "target/umutate/${{ matrix.subsystem }}" \
- --suppressions mutants/suppressions.toml \
- --summary "$GITHUB_STEP_SUMMARY" || true
- - name: Upload artifacts
- if: always()
- uses: actions/upload-artifact@v4
- with:
- name: spec-gate-mutation-${{ matrix.subsystem }}
- path: target/umutate/${{ matrix.subsystem }}
- if-no-files-found: ignore
+ - name: Test the gate and the driver's guards
+ run: python3 -m unittest discover -s scripts -p 'test_*.py' -v
# ── suppression hygiene: gate on relevant PR changes, plus nightly ─────────
# `changes` scopes the hygiene job to PRs that could orphan a suppression
- # (suppressions, operators, or src edits); nightly/dispatch always run it.
+ # (suppressions, operators, or src edits) and the infrastructure job to PRs
+ # that touch its scope; nightly/dispatch always run both.
changes:
if: github.event_name == 'pull_request'
runs-on: ubuntu-24.04
outputs:
hygiene: ${{ steps.filter.outputs.hygiene }}
+ infra: ${{ steps.filter.outputs.infra }}
steps:
- uses: dorny/paths-filter@v3
id: filter
@@ -275,6 +231,11 @@ jobs:
- 'mutants/suppressions.toml'
- 'mutants/operators/**'
- 'crates/mega-evm/src/**'
+ infra:
+ - '.cargo/mutants-infra.toml'
+ - 'crates/mega-evm/src/test_utils/scenario.rs'
+ - 'scripts/mutation_gate.py'
+ - 'scripts/mutation_test.sh'
orphan-suppressions:
name: suppression hygiene
@@ -306,10 +267,10 @@ jobs:
sudo curl -fsSL https://github.com/comby-tools/comby/releases/download/1.8.1/comby-1.8.1-x86_64-linux -o /usr/local/bin/comby
sudo chmod +x /usr/local/bin/comby
comby -version
- - name: Build the full mutant universe (both engines)
+ - name: Build the full mutant universe (both engines, both scopes)
run: |
- # --package mega-evm: match the driver's scope (otherwise --list also
- # covers the CLI bins in the virtual workspace's default-members, so a
+ # --package mega-evm: match the driver's production scope (otherwise --list
+ # also covers the CLI bins in the virtual workspace's default-members, so a
# stale mega-evm suppression could be kept alive by a same-named mutant
# in another crate).
# No --exclude-re here, so function-suppressed mutants are included —
@@ -317,8 +278,19 @@ jobs:
# --colors never: CI forces CARGO_TERM_COLOR=always, which would otherwise
# embed ANSI codes and break exact suppression matching.
cargo mutants --list --package mega-evm --colors never > universe.txt
- python3 scripts/umutate.py plan --packs spec-gate \
- | grep -oE 'crates/mega-evm/[^:]+:[0-9]+:[0-9]+: spec-gate .*' >> universe.txt
+ # The infrastructure scope is a second mutant population and a suppression may live in
+ # it, so it joins the universe. Listed through the driver, so its file list stays in
+ # one place, with SUPPRESS=/dev/null so the driver emits no --exclude-re and function-
+ # suppressed mutants stay in the universe here too. The grep drops the driver's
+ # trailing progress lines and fails the step if the scope lists nothing.
+ SUPPRESS=/dev/null scripts/mutation_test.sh infra --list --colors never \
+ | grep -oE 'crates/[^:]+:[0-9]+:[0-9]+: .*' >> universe.txt
+ # The plan runs on its own so a planner failure still fails the step.
+ # Its mutant lines are grepped separately: a single-spec engine (the
+ # satin branch) has no spec gates and the pack finds nothing. grep's
+ # "no match" (exit 1) is accepted; a grep error (exit 2) still fails.
+ python3 scripts/umutate.py plan --packs spec-gate > spec-gate-plan.txt
+ grep -oE 'crates/mega-evm/[^:]+:[0-9]+:[0-9]+: spec-gate .*' spec-gate-plan.txt >> universe.txt || [ $? -eq 1 ]
echo "universe: $(wc -l < universe.txt) mutants"
- name: Check for orphan suppressions
run: |
diff --git a/.github/workflows/on-release.yml b/.github/workflows/on-release.yml
index c6ff19453..9fab3482f 100644
--- a/.github/workflows/on-release.yml
+++ b/.github/workflows/on-release.yml
@@ -106,8 +106,10 @@ jobs:
- uses: foundry-rs/foundry-toolchain@b00af27efadbc7b4ca8b82abbd903b17cc874d2a # v1
+ # Selected by manifest path: the tool links the released mega-evme 1.7.1
+ # as its legacy leg, so `-p mega-evme` names two packages.
- name: Build mega-evme
- run: cargo build --release --locked -p mega-evme
+ run: cargo build --release --locked --manifest-path bin/mega-evme/Cargo.toml
# The built binary must report the tag's version (`mega-evme X.Y.Z`):
# a mismatch warns on a rehearsal and stops a release; a binary that
diff --git a/.github/workflows/price-grid.yml b/.github/workflows/price-grid.yml
new file mode 100644
index 000000000..2abdcc19d
--- /dev/null
+++ b/.github/workflows/price-grid.yml
@@ -0,0 +1,63 @@
+name: Byte-price grid
+
+# Runs the mega-evm test suite at state and history byte prices other than the constants, through
+# the `satin-price-override` feature and the MEGA_SATIN_CPSB / MEGA_SATIN_CPHB variables
+# (scripts/price_grid.sh). Both prices are provisional until the economics sign-off, so the suite
+# must hold at any price it may end at, and a test that only holds at the constants shows here:
+#
+# - on a pull request, five points: both bytes free, both at one gas (1 / 1), the cheapest and the
+# dearest pair under consideration (312.5 / 20 and 5000 / 300), and a point past every candidate
+# (10000 / 1000);
+# - nightly and on dispatch, the whole grid: a cost per state byte of 0, 1, 312.5, 700, 1530, 2000,
+# 5000 and 10000 by a cost per history byte of 0, 1, 20, 50, 88, 100, 200, 300 and 1000, and 0.001
+# on both.
+#
+# The run at the constants is the `test` job of build-and-test.yml.
+
+on:
+ workflow_dispatch:
+ pull_request:
+ schedule:
+ - cron: "0 4 * * *"
+
+permissions:
+ contents: read
+
+concurrency:
+ group: ${{ github.workflow }}-${{ github.ref }}
+ cancel-in-progress: true
+
+jobs:
+ price-grid:
+ name: byte-price grid
+ runs-on: ubuntu-24.04
+ # The pull-request points take minutes; the nightly grid runs the suite 73 times.
+ timeout-minutes: 90
+ steps:
+ - uses: actions/checkout@v4
+ with:
+ submodules: recursive
+
+ - name: Install Rust
+ uses: actions-rust-lang/setup-rust-toolchain@v1
+
+ - name: Install Foundry
+ uses: foundry-rs/foundry-toolchain@v1
+
+ - name: Run the suite at each point
+ env:
+ EVENT: ${{ github.event_name }}
+ run: |
+ if [ "$EVENT" = "pull_request" ]; then
+ scripts/price_grid.sh --pr
+ else
+ scripts/price_grid.sh --full
+ fi
+
+ - name: Upload the logs of a failing run
+ if: failure()
+ uses: actions/upload-artifact@v4
+ with:
+ name: price-grid-logs
+ path: target/price-grid/
+ retention-days: 7
diff --git a/.github/workflows/replay-bench.yml b/.github/workflows/replay-bench.yml
deleted file mode 100644
index b371d8737..000000000
--- a/.github/workflows/replay-bench.yml
+++ /dev/null
@@ -1,264 +0,0 @@
-name: Replay Throughput Benchmark
-
-# Replays a corpus of real, characteristic MegaETH mainnet transactions
-# (committed self-contained fixtures, timed by `state-test --bench`) and compares
-# PR throughput against the merge-base, so a change that slows down (or speeds
-# up) real-transaction execution is visible on the PR.
-#
-# This is the real-transaction counterpart to the synthetic Criterion suite in
-# benchmark.yml, and follows the same hardened structure: the job that compiles
-# and runs untrusted PR code (`bench`) is read-only, and only the jobs that touch
-# the PR (`prepare`, `compare`) get a write-scoped token — so a malicious PR run
-# triggered with `/replay-bench` has no write token to abuse.
-
-on:
- schedule:
- - cron: '0 3 * * 1' # Weekly Monday 3am UTC (after the Criterion job)
- workflow_dispatch:
- issue_comment:
- types: [created]
-
-# Suffixed with "is this a real trigger" so unrelated comments (bots, chat)
-# land in their own group instead of cancelling a live run — same fix as
-# benchmark.yml: mirror the FULL trigger gate (PR-comment + /replay-bench +
-# author association); a comment that would fail the gate must not cancel a
-# live run it cannot replace.
-concurrency:
- group: ${{ github.workflow }}-${{ github.event.issue.number || github.ref }}-${{ github.event_name != 'issue_comment' || (github.event.issue.pull_request && contains(github.event.comment.body, '/replay-bench') && contains(fromJSON('["MEMBER","COLLABORATOR","OWNER"]'), github.event.comment.author_association)) }}
- cancel-in-progress: true
-
-permissions:
- contents: read
-
-jobs:
- # Resolve the exact commits ONCE, up front, via the API only — no checkout and
- # no fetch of the PR ref — so this write-privileged job never brings untrusted
- # PR code (or even a PR-controlled ref) into the workspace.
- prepare:
- name: Resolve commits
- runs-on: blacksmith-2vcpu-ubuntu-2404
- timeout-minutes: 10
- permissions:
- contents: read
- pull-requests: write
- # The comment-reaction endpoint needs Issues write (a PR comment is an
- # issue comment); the reaction is also wrapped non-fatally below.
- issues: write
- if: >-
- github.event_name != 'issue_comment' || (
- github.event.issue.pull_request &&
- contains(github.event.comment.body, '/replay-bench') &&
- (github.event.comment.author_association == 'MEMBER' ||
- github.event.comment.author_association == 'COLLABORATOR' ||
- github.event.comment.author_association == 'OWNER')
- )
- outputs:
- feature_sha: ${{ steps.resolve.outputs.feature_sha }}
- baseline_sha: ${{ steps.resolve.outputs.baseline_sha }}
- compare: ${{ steps.resolve.outputs.compare }}
- steps:
- - name: Resolve commits and react
- id: resolve
- uses: actions/github-script@v7
- with:
- script: |
- if (context.eventName !== 'issue_comment') {
- // schedule / workflow_dispatch: measure the checked-out ref,
- // no baseline comparison.
- core.setOutput('feature_sha', context.sha);
- core.setOutput('baseline_sha', '');
- core.setOutput('compare', 'false');
- return;
- }
- const { owner, repo } = context.repo;
- const pull_number = context.payload.issue.number;
- const pr = await github.rest.pulls.get({ owner, repo, pull_number });
- const featureSha = pr.data.head.sha;
- // The compare endpoint's merge_base is the commit `git merge-base`
- // would pick for the PR base branch and head.
- const cmp = await github.rest.repos.compareCommitsWithBasehead({
- owner,
- repo,
- basehead: `${pr.data.base.ref}...${featureSha}`,
- });
- core.setOutput('feature_sha', featureSha);
- core.setOutput('baseline_sha', cmp.data.merge_base_commit.sha);
- core.setOutput('compare', 'true');
- core.info(`Feature: ${featureSha} Baseline: ${cmp.data.merge_base_commit.sha}`);
- // Cosmetic acknowledgement — never let it fail the run (and so block
- // the benchmark) if the token lacks the reaction permission.
- try {
- await github.rest.reactions.createForIssueComment({
- owner,
- repo,
- comment_id: context.payload.comment.id,
- content: 'rocket',
- });
- } catch (e) {
- core.warning(`Could not react to the comment: ${e.message}`);
- }
-
- # Compiles and runs untrusted PR code (the PR's state-test binary + driver +
- # corpus), so it is read-only: there is no write-scoped token to exfiltrate.
- # `pull-requests: read` lets `gh pr checkout` resolve a fork PR head.
- bench:
- name: Replay throughput
- needs: prepare
- runs-on: blacksmith-32vcpu-ubuntu-2404
- timeout-minutes: 90
- permissions:
- contents: read
- pull-requests: read
- steps:
- - uses: actions/checkout@v4
- with:
- submodules: recursive
- fetch-depth: 0
- # This job builds and runs untrusted PR code; don't leave a git
- # credential on disk for that code to pick up.
- persist-credentials: false
-
- - name: Fetch PR head
- if: github.event_name == 'issue_comment'
- env:
- GH_TOKEN: ${{ github.token }}
- run: gh pr checkout ${{ github.event.issue.number }}
-
- - name: Install Rust
- uses: actions-rust-lang/setup-rust-toolchain@v1
-
- - name: Install Foundry
- uses: foundry-rs/foundry-toolchain@v1
-
- # Only the binary under test changes between feature and baseline; the
- # driver + corpus always come from the PR-head checkout. Build each binary
- # at its pinned SHA into its own directory the driver resolves.
- - name: Build feature binary
- run: |
- git checkout --quiet ${{ needs.prepare.outputs.feature_sha }}
- git submodule update --init --recursive
- cargo build --release -p state-test
- mkdir -p /tmp/pr && cp target/release/state-test /tmp/pr/
-
- - name: Build baseline binary
- if: needs.prepare.outputs.compare == 'true'
- run: |
- git checkout --quiet ${{ needs.prepare.outputs.baseline_sha }}
- git submodule update --init --recursive
- cargo build --release -p state-test
- mkdir -p /tmp/base && cp target/release/state-test /tmp/base/
-
- # Restore the PR-head driver + corpus, then run. If the baseline predates
- # `state-test --bench` (the feature this PR may introduce), fall back to
- # measuring the feature binary alone instead of failing.
- - name: Run replay benchmark
- run: |
- git checkout --quiet ${{ needs.prepare.outputs.feature_sha }}
- git submodule update --init --recursive
- BINS=(--bin "pr=/tmp/pr")
- if [ "${{ needs.prepare.outputs.compare }}" = "true" ] && \
- /tmp/base/state-test --bench --bench-runs 1 --bench-warmup 0 \
- bench/replay/fixtures/medium_call.json >/dev/null 2>&1; then
- BINS=(--bin "base=/tmp/base" --bin "pr=/tmp/pr")
- echo "Comparing PR vs baseline."
- else
- echo "Measuring the PR binary only (no baseline, or baseline predates the fixture bench)."
- fi
- python3 bench/replay/run.py "${BINS[@]}" \
- --rounds 7 --threshold-pct 7 \
- --markdown-out replay-bench.md \
- --json-out replay-bench.json
-
- - name: Write job summary
- if: always()
- run: |
- if [ -f replay-bench.md ]; then
- {
- cat replay-bench.md
- echo
- echo "> Comparing \`baseline\` (${{ needs.prepare.outputs.baseline_sha }}) → \`feature\` (${{ needs.prepare.outputs.feature_sha }})."
- echo "> Sub-10µs cases are noisy on shared runners; read the larger cases and the trend for real signal."
- } >> "$GITHUB_STEP_SUMMARY"
- fi
-
- # Upload the machine-readable JSON (not just the rendered markdown): the
- # trusted compare job re-renders the table from these numbers so it never
- # posts PR-controlled strings (case names/notes) verbatim. The markdown is
- # kept only for the job summary above.
- - name: Upload report
- if: always()
- uses: actions/upload-artifact@v4
- with:
- name: replay-bench-report
- path: |
- replay-bench.json
- replay-bench.md
- if-no-files-found: ignore
-
- # Posts the comparison comment. Consumes only the report artifact, never PR
- # code, so it can safely hold a write-scoped token.
- compare:
- name: Comment on PR
- needs: [prepare, bench]
- runs-on: blacksmith-2vcpu-ubuntu-2404
- timeout-minutes: 10
- if: needs.prepare.outputs.compare == 'true'
- permissions:
- contents: read
- pull-requests: write
- steps:
- - name: Download report
- uses: actions/download-artifact@v4
- with:
- name: replay-bench-report
-
- - name: Comment on PR
- uses: actions/github-script@v7
- with:
- script: |
- const fs = require('fs');
- // Re-render the table here, in the trusted (write-scoped) job, from the
- // numbers the bench job computed — never the markdown the PR's driver
- // emitted. Case name/category come from the PR's manifest, so escape
- // them; everything else is a number formatted locally.
- if (!fs.existsSync('replay-bench.json')) return;
- const summary = JSON.parse(fs.readFileSync('replay-bench.json', 'utf8'));
- const esc = (s) => String(s ?? '').replace(/\r?\n/g, ' ').replace(/[|`<>\\]/g, '\\$&').slice(0, 80);
- const fmtNs = (ns) => ns >= 1e6 ? `${(ns / 1e6).toFixed(3)} ms` : ns >= 1e3 ? `${(ns / 1e3).toFixed(2)} µs` : `${Math.round(ns)} ns`;
- const fmtInt = (n) => Math.round(n).toLocaleString('en-US');
- const labels = summary.labels || [];
- const compare = labels.length === 2;
- const lines = [];
- if (compare) {
- const [base, pr] = labels;
- lines.push(`| transaction | category | gas | \`${esc(base)}\` median | \`${esc(pr)}\` median | Δ time | \`${esc(base)}\` Mgas/s | \`${esc(pr)}\` Mgas/s | verdict |`);
- lines.push('|---|---|--:|--:|--:|--:|--:|--:|---|');
- for (const c of summary.cases) {
- const d = `${c.delta_pct >= 0 ? '+' : ''}${c.delta_pct.toFixed(1)}%`;
- lines.push(`| ${esc(c.name)} | ${esc(c.category)} | ${fmtInt(c.gas)} | ${fmtNs(c.base_median_ns)} | ${fmtNs(c.pr_median_ns)} | ${d} | ${fmtInt(c.base_mgas_per_sec)} | ${fmtInt(c.pr_mgas_per_sec)} | ${esc(c.verdict)} |`);
- }
- } else {
- const only = labels[0] || 'pr';
- lines.push(`| transaction | category | gas | \`${esc(only)}\` median | \`${esc(only)}\` Mgas/s |`);
- lines.push('|---|---|--:|--:|--:|');
- for (const c of summary.cases) {
- lines.push(`| ${esc(c.name)} | ${esc(c.category)} | ${fmtInt(c.gas)} | ${fmtNs(c.median_ns)} | ${fmtInt(c.mgas_per_sec)} |`);
- }
- }
- let table = lines.join('\n');
- if (compare) {
- table += `\n\n**${summary.cases.length} transactions — ${fmtInt(summary.regressions)} regression(s), ${fmtInt(summary.improvements)} improvement(s)** (threshold ±${Number(summary.threshold_pct).toFixed(1)}% on median time; ABBA-interleaved).`;
- }
- const base = '${{ needs.prepare.outputs.baseline_sha }}';
- const head = '${{ needs.prepare.outputs.feature_sha }}';
- const repo = context.payload.repository.html_url;
- const body =
- table +
- `\n\n> Comparing [\`baseline\`](${repo}/commit/${base}) → [\`feature\`](${repo}/commit/${head}).` +
- `\n> Sub-10µs cases are noisy on shared runners; read the larger cases and the overall trend.`;
- await github.rest.issues.createComment({
- owner: context.repo.owner,
- repo: context.repo.repo,
- issue_number: context.issue.number,
- body,
- });
diff --git a/.gitignore b/.gitignore
index de945a462..4a559fb23 100644
--- a/.gitignore
+++ b/.gitignore
@@ -8,3 +8,8 @@
# Python bytecode cache (scripts/)
__pycache__/
+
+# insta's pending snapshots: a differing snapshot's new value, written beside it outside CI, until
+# it is reviewed and accepted (or rejected) with `cargo insta review`.
+*.snap.new
+*.pending-snap
diff --git a/AGENTS.md b/AGENTS.md
index 6f4e03b8d..44acd821e 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -4,19 +4,56 @@ This file provides guidance to AI agents (e.g., claude code, codex, cursor, etc.
## Project Overview
-MegaEVM (mega-evm) — a specialized EVM implementation for MegaETH, built on **revm** and **op-revm** by customizing several hooks exposed by trait of revm.
+MegaEVM (mega-evm) — a specialized EVM implementation for MegaETH, built on **revm** and **op-revm** by customizing the hooks revm exposes through its traits.
+
+This branch (`satin`) builds **Satin**, the new engine's first spec, on the MegaETH fork of revm 40.0.3 and the MegaETH fork of op-revm 20.0.0.
+Today's `main` is the legacy engine; the specs after Satin are added to this engine (see Spec System below).
+The legacy engine (specs `Equivalence` through `Rex6`, the 1.x crate line on crates.io revm 27) is frozen and is not edited here.
+Satin follows Rex6 on the spec ladder and is the one unstable spec.
+
+Every mechanism of the Satin spec is in place; the module table below says where each lives.
## Build & Development Commands
```bash
-# Build
-cargo build
-cargo build --release -p mega-evme # CLI tool
+# Build (plain `cargo build`, `cargo check` and `cargo test` cover only the default member, mega-evm)
+cargo build --workspace
# Test
-cargo test # all tests
+cargo test --workspace # all tests
+# The debug CI job: the same run through cargo-insta, failing on a differing or unreferenced snapshot
+cargo insta test --workspace --check --unreferenced=reject --test-runner cargo-test --no-quiet --fail-fast
+cargo insta review # go through the .snap.new files a failing local run wrote
+cargo test --workspace --release --locked # the release CI job
cargo test -p mega-evm # core crate only
cargo test -p mega-evm -- test_name # single test
+cargo test --manifest-path bin/mega-evme/Cargo.toml # the mega-evme tool (not `-p`: it links mega-evme 1.7.1)
+
+# The gas schedule's byte prices are an input; this feature lets a measurement build change them
+cargo test -p mega-evm --features satin-price-override,test-utils
+# Run the suite with MEGA_SATIN_CPSB and MEGA_SATIN_CPHB unset: with either of them set the tests
+# that assert the spec's own byte prices skip, and the suite checks less than it looks like it does
+
+# The suite at other byte prices, as the byte-price grid job runs it (logs under target/price-grid)
+scripts/price_grid.sh --pr # five points; --full for the whole grid, or name points: 312.5/20
+
+# Regenerate the checked-in pricing table after an intentional schedule or engine change
+UPDATE_SATIN_PRICING_TABLE=1 cargo test -p mega-evm --test satin
+
+# The execution-spec gate (see Test Gates): Ethereum's state-test fixtures through MegaEvm, per fork
+cargo run --release -p state-test -- --fork Osaka /state_tests
+cargo run --release -p state-test -- --fork Amsterdam /state_tests
+cargo run --release -p state-test -- --mode satin --fork Osaka /state_tests # the report
+# The blockchain tests through the block executor, with the pins the gate's job passes
+cargo run --release -p state-test -- btest /blockchain_tests --expect-deviations
+# The witness replay over the fixtures, as the gate's job runs it: every file (SAMPLE=0), per fork and mode,
+# the fixtures named by an absolute path (the test runs in the package's directory)
+MEGA_STATE_TEST_FIXTURES=$PWD//state_tests MEGA_STATE_TEST_SAMPLE=0 MEGA_STATE_TEST_FORK=Osaka \
+ MEGA_STATE_TEST_MODE=satin cargo test --release -p mega-state-test --test witness -- --ignored --nocapture
+# The whole-outcome digest: one line per executed transaction (the canonical record of its MegaTransactionOutcome, hashed; `-full` adds the record), for a base-against-head `sort | cmp`
+cargo run --release -p state-test -- --mode satin --fork Osaka /state_tests --json-digest 2>&1 >/dev/null | grep '^{' | sort > head.digest
+# Regenerate the rendered deviation registry after changing crates/mega-state-test/src/deviations.rs
+UPDATE_DEVIATIONS=1 cargo test -p mega-state-test --lib deviations
# Check compiler errors (preferred over clippy for quick checks)
cargo check
@@ -27,229 +64,553 @@ cargo fmt --all --check
cargo clippy --workspace --lib --examples --tests --benches --all-features --locked
cargo sort --check --workspace --grouped --order package,workspace,lints,profile,bin,benches,dependencies,dev-dependencies,features
-# Benchmarks
-cargo bench -p mega-evm --bench transact # wall-clock + HTML report
+# Benchmarks: `transact` (MegaEvm next to op-revm), `corpus` (JSON scenarios, a bench input), `factory` (EVM construction), `block` (a block through MegaBlockExecutor)
+cargo bench -p mega-evm --bench # wall-clock + HTML report
cargo codspeed build -p mega-evm --bench && cargo codspeed run # instruction counts (Linux only)
# no_std check (run against riscv target)
cargo check -p mega-evm --target riscv64imac-unknown-none-elf --no-default-features
+# The declared minimum toolchain, as CI's msrv job runs it
+cargo +1.94.0 check --workspace --all-targets --all-features --locked
+
# System contracts (requires Foundry)
cd crates/system-contracts && forge build
+cd crates/system-contracts && forge test # the system-contract CI job
```
Git submodules are required — clone with `--recursive` or run `git submodule update --init --recursive`.
## Workspace Structure
-| Crate | Path | Purpose |
-| ----------------------- | ------------------------- | ------------------------------------------------------------------------------------------- |
-| `mega-evm` | `crates/mega-evm` | Core EVM implementation |
-| `mega-system-contracts` | `crates/system-contracts` | Solidity system contracts with Rust bindings (Foundry-based) |
-| `mega-state-test` | `crates/mega-state-test` | State-test fixtures + runner library (EEST-compatible, published; imported as `state_test`) |
-| `state-test` | `crates/state-test` | Thin CLI front-end over `mega-state-test` (not published) |
-| `mega-evme` | `bin/mega-evme` | CLI tool for EVM execution (`run`, `tx`, `replay`) |
-| `mega-t8n` | `bin/mega-t8n` | Standalone state transition (t8n) tool |
+| Crate | Path | Member | Purpose |
+| ----------------------- | ------------------------- | ------ | ---------------------------------------------------------------------------------------- |
+| `mega-evm` | `crates/mega-evm` | yes | The Satin engine |
+| `mega-system-contracts` | `crates/system-contracts` | yes | Solidity system contracts with Rust bindings (Foundry-based) |
+| `mega-state-test` | `crates/mega-state-test` | yes | Execution-spec runner on Satin: the state-test gate and report, the blockchain-test gate |
+| `state-test` | `crates/state-test` | yes | The runner's CLI |
+| `mega-evme` | `bin/mega-evme` | yes | EVM execution CLI: Satin in-tree, legacy specs on the released 1.7.1 CLI |
+
+`mega-evme` runs a command on the engine its spec names: `Satin` on the in-tree sources, a spec from `Equivalence` to `Rex6` on the released `mega-evme` 1.7.1 and `mega-evm` 1.7.1, which it links under the aliases `mega-evme-legacy` and `mega-evm-legacy` (its `legacy` feature, on by default).
+Because it links a package of its own name, select it by manifest path, not with `-p`: `cargo test --manifest-path bin/mega-evme/Cargo.toml`.
+The legacy line's versions are pinned to the 1.7.1 release's lockfile and guarded by `bin/mega-evme/tests/legacy_line.rs`, the precompiles' backends and the encodings it shares with the engine included; the few the engine's alloy 2 line holds above the release are pinned where they are.
+
+### Dependencies on the forks
+
+The root `Cargo.toml` pins `revm = "=40.0.3"` and redirects all twelve revm crates to the MegaETH fork with `[patch.crates-io]`.
+`op-revm` is declared from the OP monorepo revision the node locks and redirected to the MegaETH fork of op-revm with `[patch."https://github.com/ethereum-optimism/optimism"]`; the OP alloy crates the engine links (`alloy-op-evm`, `op-alloy-consensus`, `op-alloy-network`, `op-alloy-rpc-types`) come from the same monorepo revision, and `op-alloy-flz` is a crates.io pin.
+
+- Patch the twelve revm crates together, or the build resolves a second copy of revm.
+- `cargo tree -i revm` must show exactly one revm, from the fork: the engine's graph (the default member) never reaches another.
+ The workspace also locks revm 27.1.0, linked only by `mega-evme`: its `legacy` feature, and its `mega-state-test` 1.7.1 dev-dependency, which is unconditional, so a test build without `legacy` links it too (`cargo tree --workspace -i revm@27.1.0`).
+- The fork pins move by editing the patch blocks; commit the regenerated `Cargo.lock` with them.
+- Gas detention builds on the fork's withheld part of a frame's regular gas (`GasTracker::limit_spendable`, `withheld_crossing`, `set_withheld_crossing`), whose crossing record holds the regular gas the frame had before the charge that crossed (`WithheldCrossing::remaining`), on the fork's failed-charge record, the regular gas a frame had before every deduction that failed and before a halt on a cold access it could not pay (`failed_charge_remaining`, `set_failed_charge_remaining`), which tells what a halting frame burned, and on the fork's precompile price (`Precompile::required_gas`), none of which upstream revm has.
+- Writes and frame starts are metered inside revm's instructions, through the fork's two instruction hooks on `Host`, which upstream revm does not have: `SSTORE`, `LOG0`–`LOG4` and `SELFDESTRUCT` call `write_completed` once the write is in the journal and every charge they make has been made, and the four calls and two creations call `frame_starting` once the forward is taken and before the frame's input is built.
+ `CompletedWrite` and `FrameStartKind` are exhaustive on purpose, so the engine's matches over them carry no wildcard arm and a new kind is a compile error here.
+- The actions the engine makes for a frame outside an instruction — a `keylessDeploy` call's creation and its answer, and the stop of a frame a child returned into over a limit — come back through revm's own frame run, plain or inspected: the fork's run returns an action set on a frame's interpreter before it runs without running an instruction or calling the inspector's `step`, and its inspected frame start hands a frame built with one to no `initialize_interp`, so the engine's `frame_run` only forwards to revm's.
+ A frame's own end is decided in the fork's run-result hook (`EvmTr::frame_run_result`), which revm's plain and inspected loops call once a frame's run returns and before the inspector's `call_end`, `create_end` and `frame_end` and `frame_return_result`: gas detention's classification is made there, so an inspector sees the stop the caller gets.
+- The fork pins at a published commit of its byte-pool branch, and op-revm at a published commit that settles the first frame through the revm fork's shared settlement (`execution::settle_first_frame`), both by revision until the fork's review is done.
+ The byte-pool branch carries three resource pools on every frame's gas tracker, which the engine gives their meaning (`PoolId`, `GasTracker::record_pool`, `refill_pool`, `pool_remaining`, `pool_spent`), each forwarded at every start as the schedule's share (`GasId::pool_kept_percent`, the part the caller keeps) and settled as the reservoir is, and the reservoir itself forwarded by its own share (`GasId::reservoir_kept_percent`, `GasTracker::forward_to_child`), the child's return adding what it left to what the caller kept; a start charge the frame-start hook declares on the start (`FrameStart::charge`, `StartCharge`) and the fork refunds when the frame fails; the history allowance a value call gives its child (`GasId::call_history_allowance`, `GasTracker::draw_history_allowance`); a creation's address on its start (`FrameStart::target`) and a `SELFDESTRUCT`'s moved balance on its completed write (`CompletedWrite::SelfDestruct::balance`).
+ The fork does not split a system call's gas or report the reservoir on `ResultGas`: Satin does both itself (`MegaHandler::tx_gas`, `AdditionalLimit::reservoir_remaining`), and its op-revm baselines run op-revm through a reference handler that does the same (`tests/shared/op_reference.rs`).
+ Its switch back to revm 40.0.3's journal semantics (`CfgEnv::legacy_journal_semantics`) is the legacy engine's: Satin's spec and neutral configurations fix it off.
+- The op-revm fork prices its size-limited precompiles through that hook, which upstream op-revm does not, so gas detention decides a call to the BN254 pairing or a BLS12-381 MSM or pairing from its price rather than running it on the allowance.
+- The limits hold deployed code at the fork's code-deposit admission (`ContextTr::admit_code_deposit`), which `return_create` asks after every deposit charge and before it commits the creation, lending it the creating frame's tracker, whose pool the code's bytes are drawn from.
## Architecture
### Spec System (`MegaSpecId`)
-Progression: `EQUIVALENCE` → `MINI_REX` → `MINI_REX_1` → `MINI_REX_2` → `REX` → `REX1` → `REX2` → `REX3` → `REX4` → `REX5` → `REX6` → `REX7` (`MINI_REX_1`/`MINI_REX_2` are alias rungs executing `EQUIVALENCE` and `MINI_REX` behavior respectively)
-
-- **Spec** defines EVM behavior (what the EVM does).
- Defined in `crates/mega-evm/src/evm/spec.rs`.
- The code base **MUST** maintain **backward-compatibility**, which means the semantics (i.e., EVM behaviors) must remain the same for existing specs.
- The only exception for this is the **unstable** spec that is under active development (if exists, must be the latest one).
- - _`REX7` is the current unstable spec under active development._
- When a new spec is introduced, this line should be updated to indicate the unstable spec.
- - Frozen and activated are separate properties.
- `REX6` is frozen and activated on both networks (see `block/chain.rs`); `REX7` has no activation timestamp yet.
- Freezing forbids further semantic change; scheduling is a later, separate decision made in the node chainspecs and mirrored here in `block/chain.rs` for replay tooling.
- - Specifications of each behavior-introducing spec can be found in the upgrade pages under `docs/spec/upgrades/`; alias rungs have no page of their own and are recorded in the upgrade overview and `docs/spec/hardfork-spec.md`.
-- **Hardfork** (`MegaHardfork`) defines network upgrade events (when specs activate).
- Every hardfork schedules a spec rung of its own — the fork→spec mapping is 1:1.
- `MiniRex1` and `MiniRex2` schedule the alias specs `MINI_REX_1` and `MINI_REX_2`, whose `behavior()` projects to `EQUIVALENCE` and `MINI_REX` respectively.
- Defined in `crates/mega-evm/src/block/hardfork.rs`.
-- All specs use `OpSpecId::ISTHMUS` as the Optimism base layer.
- But this is subject to change in the future.
-
-### Core Source Layout (`crates/mega-evm/src/`)
-
-- **`evm/`** — Core mega-evm logic: spec definitions, context, factory, execution pipeline, modified opcodes (LOG, SELFDESTRUCT), host hooks, precompiles.
- This module collects all our modifications and customizations of EVM's behavior for mega-evm based on the revm.
-- **`block/`** — Block execution: executor, factory, hardfork-to-spec mapping, limit enforcement, and the canonical per-chain hardfork schedules.
- This module defines how a block in MegaETH block should be executed.
- `block/chain.rs` is the single source of truth for the mainnet/testnet chain IDs and activation-timestamp schedules (`hardfork_schedule(chain_id)`, `MAINNET_CHAIN_ID`, `TESTNET_CHAIN_ID`, `mainnet_hardforks()`, `testnet_hardforks()`); look there to find or change when a fork activates on a given chain.
- Its unknown-chain fallback pins a named spec rather than following the latest one, so introducing a spec does not move chains that run from genesis; advancing that pin is a deliberate edit made when a spec is sealed.
- Forks map 1:1 onto an ascending spec ladder, so the resolved `spec_id` is monotone; rollbacks are alias specs (`MINI_REX_1`, `MINI_REX_2`) whose `behavior()` projects to an earlier spec.
- One value, two projections that must not be confused: `is_enabled` compares behavior and gates EVM semantics (rolls back in alias windows); `reaches` compares ladder position and gates one-way chain setup such as predeploys and pre-block rules (never rolls back).
- The `is__active_at_timestamp` predicates are position projections for behavior-introducing forks and raw event queries for alias forks, and `MegaHardforks::validate_schedule` is the load-time check that a published schedule climbs the ladder without gaps.
-- **`limit/`** — Resource limit tracking: compute gas, data size, KV updates, state growth (each in its own module).
- MegaETH introduces additional resource metering mechanism and this module implements their logic as utility structs to be used by mega-evm.
-- **`access/`** — Block env access tracking and volatile data detection for parallel execution.
- MegaETH incorporates parallel EVM, so it is essential to reduce the conflicts between transactions by restricting the access to some "hot" resources.
- This module collects the logic of tracking the access to such hot resources during transaction execution.
-- **`external/`** — External environmental context depended by mega-evm.
- The execution of mega-evm relies on some external environment information, in addition to revm's normal BlockEnv and CfgEnv.
-- **`system/`** — System contract integration.
- MegaETH provides several system contracts that are predeployed on the chain.
- Any modification of such system contract must induce a new Spec to ensure backward compatibility.
-- **`sandbox/`** — Isolated EVM execution
-- **`constants.rs`** — All numeric constants organized by spec
-- **`types.rs`** — Shared type definitions
-
-### Key Concepts
-
-#### Backward Compatibility of Specs
-
-The spec system (`MegaSpecId`) forms a linear progression where each newer behavior-introducing spec includes all previous behaviors; the alias rungs are the exception, re-executing an earlier spec's behavior instead.
-The codebase **MUST** maintain backward-compatibility: EVM semantics must never change for existing (stable) specs.
-The only exception is the latest spec if explicitly marked as **unstable**.
-Consequently:
-
-- Adding/modifying a system contract requires introducing a new spec.
-- Changing gas costs, opcode behavior, or resource limits requires a new spec.
-- Code should use `spec.is_enabled(MegaSpecId::X)` to gate spec-specific behavior.
-- Modified opcodes (e.g., SELFDESTRUCT behavior varies by spec) are wired per-spec in the instruction table (`evm/instructions.rs`).
-
-#### Dual Gas Model (Compute Gas vs Storage Gas)
-
-MegaETH separates EVM gas into two independent dimensions tracked during execution:
-
-- **Compute gas**: Measures pure computational cost.
- Every opcode's gas consumption is recorded via wrapped instructions in `evm/instructions.rs` — `compute_gas_ext::*` for plain opcodes and `storage_gas_ext::*` for storage-affecting opcodes (SSTORE, LOG, CALL-family, CREATE/CREATE2, SELFDESTRUCT) — both invoking the shared `record_storage_compute_gas!` primitive after the opcode body completes.
- Subject to a per-spec compute gas limit and further restricted by gas detention (see below).
-- **Storage gas**: Charges for persistent state modifications (SSTORE, account creation, contract deployment).
- These costs scale dynamically with SALT bucket capacity (see External Environment Dependencies below).
- LOG opcodes are charged in both dimensions: standard compute gas rates plus a storage gas multiplier on topic and data costs.
-
-Both dimensions are enforced independently.
-A transaction can be halted by exceeding either limit.
-
-#### Multidimensional Resource Limits
-
-Beyond the dual gas model, mega-evm enforces **four independent per-transaction resource limits** via `AdditionalLimit` (`limit/limit.rs`):
-
-- **Compute gas** — Computational opcode cost
-- **Data size** — Calldata + logs + storage writes + code deploy + account updates
-- **KV updates** — Storage writes + account modifications (net, with refunds)
-- **State growth** — Net new accounts + net new storage slots (not all specs enable this)
-
-Each dimension has its own per-spec limit defined in `constants.rs`.
-All trackers are **frame-aware**: reverted inner calls discard their tracked usage, successful calls merge into the parent frame.
-When any limit is exceeded, execution halts with `OutOfGas` and remaining gas is preserved for refund.
-
-#### Gas Detention (Volatile Data Access Restriction)
-
-MegaETH's parallel EVM needs to minimize conflicts between concurrent transactions.
-"Volatile" data — block environment fields (NUMBER, TIMESTAMP, COINBASE, etc.), the beneficiary's account state, and the oracle contract — is frequently read by many transactions and thus a major source of conflicts.
-
-**Gas detention** restricts computation after volatile data is accessed by capping the remaining compute gas:
-
-- Different volatile data categories (block env/beneficiary, oracle) have different cap levels defined in `constants.rs`.
-- The **most restrictive cap wins** when multiple volatile sources are accessed.
-- Caps are applied via host hooks (`evm/host.rs`) that mark access in a `VolatileDataAccessTracker` (`access/tracker.rs`), then enforced after each volatile opcode via `wrap_op_detain_gas!` in `evm/instructions.rs`.
-
-This forces transactions that touch volatile data to terminate quickly, reducing parallel execution conflicts without banning the access outright.
-Detained gas is effectively refunded — users only pay for actual computation performed.
-
-#### Storage Gas Stipend (Rex4+)
-
-MegaETH's 10× storage gas multiplier on LOG opcodes causes even `LOG1` to cost 4,500 gas, exceeding the EVM's `CALL_STIPEND` of 2,300.
-Rex4 introduced `STORAGE_CALL_STIPEND` (23,000 gas) for internal (`depth > 0`) value-transferring `CALL`/`CALLCODE`; Rex5 reworked it into a separated allowance, so the tracker is dual-mode.
-Under Rex5 the stipend is a per-frame allowance that does NOT inflate the child's `gas_limit`: it is drawn only at MegaETH's storage-gas surcharge sites (LOG topic/data, new-account materialization, first-time-write SSTORE, contract-creation storage, SELFDESTRUCT beneficiary creation), is structurally unspendable on compute, and is neither returned to the caller nor rescued for the sender — nothing is burned because nothing ever enters the frame's gas limit.
-Under Rex4 (legacy mode) the stipend instead inflates the child's `gas_limit`, a per-frame compute gas cap keeps the extra gas usable only for storage-gas-heavy operations, and unused stipend is burned on return.
-
-The stipend lifecycle is managed by `StorageCallStipendTracker` (`limit/storage_call_stipend.rs`), which maintains a per-frame stack aligned with the EVM call stack.
-The tracker's `before_frame_init` method is called inside `AdditionalLimit::before_frame_init`, after all four sub-trackers push their frames (so the compute gas frame exists for the Rex4 legacy-mode per-frame cap).
+`MegaSpecId` has one rung so far, `SATIN`, running on `OpSpecId::KARST` (Ethereum `OSAKA`).
+`MegaHardfork` has one fork so far, `Satin`, which activates `SATIN`.
-The storage gas stipend is subject to the general gas leakage pitfalls described below.
+- `SATIN` is the unstable spec under active development: it has no activation timestamp yet (`block/chain.rs` lists the two chains with the Satin timestamp unset), and its behavior may change until it is sealed.
+- Display and `FromStr` use `"Satin"`; serde uses the variant name `"SATIN"`.
+- The legacy spec names (`Equivalence` … `Rex6`) parse to `ParseMegaSpecError::Legacy`; they are never mapped to Satin.
+- There are no spec gates yet: with one rung there is nothing to gate.
+- The next spec is added as the legacy engine added Rex1 (#115, eleven files): a `MegaSpecId` variant after `SATIN` with its name and its `into_op_spec` arm; a `MegaHardfork` variant that activates it, and a params mechanism if it is the first fork to need chain-configuration parameters (Satin carries none); an `is_enabled`-style ordering on `MegaSpecId` and a gate at every site whose behavior changes; the constants it changes, keyed by spec, a limit it changes as its own arm of `ProtocolLimits::for_spec`; and its upgrade page under `docs/spec/upgrades/`.
+ From then on Satin's behavior is fixed: a gate keeps Satin's path as it is.
+ The extension points it builds on are already in place: the spec argument the factory and the context take, the per-spec limits table, and `into_op_spec`.
-#### System Contracts
-
-MegaETH pre-deploys system contracts at well-known addresses (`0x634200...0001`, `0002`, `0003`, etc.).
-They are deployed idempotently during `pre_execution_changes()` in `block/executor.rs`, gated by hardfork activation:
-
-| Contract | Address suffix | Purpose |
-| ------------------------ | -------------- | --------------------------------------------------- |
-| Oracle | `...0001` | External key-value storage with hint support |
-| High-Precision Timestamp | `...0002` | Sub-second block timestamp |
-| Keyless Deploy | `...0003` | Deterministic contract deployment via Nick's Method |
-| MegaAccessControl | `...0004` | Access control (disableVolatileDataAccess) |
-| MegaLimitControl | `...0005` | Limit query/control (currently remainingComputeGas) |
-| SequencerRegistry | `...0006` | System address and sequencer role registry |
-
-Key design aspects:
-
-- Solidity sources in `crates/system-contracts/contracts/`, compiled by Foundry, with Rust ABI bindings generated via `alloy-sol-types`.
-- Bytecode is versioned and hash-verified at build time (`crates/system-contracts/build.rs`).
-- The **MEGA_SYSTEM_ADDRESS** can call whitelisted system contracts as deposit-like transactions — no signature or fee required.
- This is how the sequencer updates oracle storage.
-- **Any system contract modification requires a new spec** to preserve backward compatibility.
-
-#### External Environment Dependencies
-
-mega-evm requires external context beyond revm's standard `BlockEnv`/`CfgEnv`, provided via the `ExternalEnvFactory` trait (`external/factory.rs`):
-
-- **SALT environment** (`external/salt.rs`): Provides bucket capacity data for dynamic gas pricing.
- Each account and storage slot maps to a SALT bucket; gas cost = base cost × (bucket_capacity / MIN_BUCKET_SIZE).
- This makes storage operations more expensive in crowded state regions, preventing state bloat.
- Implementation: `DynamicGasCost` struct (`external/gas.rs`) lazily caches bucket multipliers.
-- **Oracle environment** (`external/oracle.rs`): Supplies storage values for the oracle contract via `get_oracle_storage(slot)`.
- Oracle reads in `sload` are **always forced cold** for deterministic replay.
- The `on_hint(from, topic, data)` callback enables synchronous oracle hints during execution.
-- An `EmptyExternalEnv` implementation disables both features (returns minimum bucket size, no oracle data) for testing or standalone use.
-
-### Gas Leakage Pitfalls
-
-Any mechanism that grants, inflates, or adjusts gas on a per-frame basis (e.g., `STORAGE_CALL_STIPEND`, and any future per-frame gas adjustment) must account for all frame termination paths.
-Failing to do so can cause system-granted gas to leak back to the parent call frame or the transaction sender.
-The following paths are common sources of leakage:
-
-1. **System contract interception** (`system/intercept.rs`): Interceptors short-circuit `frame_init` before `AdditionalLimit::before_frame_init` runs, producing a synthetic `FrameResult` without a real child EVM frame.
- Any per-frame gas adjustment applied in `before_frame_init` is skipped on this path.
- The `push_empty_frame()` call maintains stack alignment but does not apply adjustments.
- Synthetic results must not assume any per-frame gas mechanism was applied.
-2. **Gas rescue on TX-level limit exceed** (`limit/limit.rs`): When a transaction-level resource limit is exceeded, `rescue_gas` captures remaining gas for sender refund.
- If a frame's gas was inflated by a per-frame mechanism, the rescued amount must exclude the inflated portion — otherwise the sender recovers system-granted gas that should have been burned.
-3. **Frame return** (`limit/limit.rs`): `before_frame_return_result` is the final hook before gas is returned to the parent.
- Any per-frame gas adjustment must be unwound here (e.g., burning unused granted gas).
- The unwinding must apply identically on success and revert — conditional unwinding can leak gas on one path.
-
-When adding a new per-frame gas mechanism, verify that all three paths handle it correctly and add tests for each.
-
-### Resource-Limit Check Protocol
+### Core Source Layout (`crates/mega-evm/src/`)
-The per-opcode hot path records and checks only the compute-gas dimension (`AdditionalLimit::record_compute_gas`).
-Correctness of the other three dimensions (data size, KV updates, state growth) rests on a protocol instead of a per-opcode fan-out across all four trackers:
+| Module | Holds |
+| -------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `evm/` | `MegaSpecId`; `MegaContext`; `MegaEvm` over revm's `Evm` with its own frame start and return, which revm's plain and inspected loops share (detention's hooks and its hold on answered frames included), the interceptor scheme guard, the keyless dispatch, the hand-made actions of the `keylessDeploy` call's frame and its creation's return into it, the system-transaction promotion in `MegaHandler` over op-revm's handler, the split of a system call's gas at `SYSTEM_CALL_REGULAR_GAS_LIMIT` (`MegaHandler::tx_gas`) and the read of the reservoir a result settled with (`execution.rs`); the completed-write and frame-start hooks — a completed write's record, drawn on the frame's pool, held to the limits and charged its history, a same-transaction destruction's give-back, and a frame start's records, charged to the caller after the forward and declared on the start — the SALT pricing hook, the block-hash, SALT-bucket and oracle-read records a stateless witness needs, the Oracle's storage read through the oracle service, the volatile-read marks and refusals (`host.rs`, `state.rs`); the volatile-read wrappers and the Amsterdam opcode activation (`instructions.rs`); the Satin gas schedule (`schedule.rs`) and the byte prices it is built from (`prices.rs`); what a history byte costs and how many each site appends (`history.rs`); the Satin precompile set with the repriced KZG, which calls gas detention may price from it, and the precompile provider, alloy-evm's, run on the context `MegaContext` wraps (`precompiles.rs`); synthetic frame results (`frame.rs`); what an inspector sees and may rewrite, run on revm's inspected lifecycle unchanged (the module doc); `MegaTransactionOutcome`, `MegaGasUsage` (`result.rs`); `MegaEvmFactory` and its dynamic precompile builder (alloy-evm); the EIP-7708 switch the spec fixes on and the legacy journal switch it fixes off, whether the running execution is a system call whose gas is split (`splits_system_call_gas`), whether the running transaction is the protocol's own, and the code-deposit admission (`context.rs`); the count and hold of a frame's start once revm decided it, on the pool its frame starts with, the cap on a child's share, and a creator's nonce record counted on the creator once its creation returned (`hold_creator`) (`execution.rs`); the system-call entry points, the pre-block calls' on `PRE_BLOCK_CALL_GAS_LIMIT` among them (`mod.rs`); `spec_cfg`, the configuration the spec fixes, exported for a node's `EvmEnv` (`context.rs`); a pool's validation without state through the handler's own phases and `IntrinsicGas`, the intrinsic gas by ledger (`validation.rs`) |
+| `block/` | `MegaHardfork`, `MegaHardforks`, `MegaHardforkConfig` and the load-time schedule validation (`hardfork.rs`); the chain table and the canonical schedules (`chain.rs`); `MegaBlockExecutor` with the Karst block rules, `MegaBlockExecutorFactory`; `ProtocolLimits::for_spec`, the one per-spec table of the limits every node shares (the per-transaction runtime limits and the block's data-size, KV-update and state-growth budgets), `BlockLimits`, the builder's packing policy that can only tighten them, `BlockLimiter` with the block's gas limit, the header's, and its three packing budgets (`limit.rs`); `BlockGasCounters` (the three ledgers and the history bytes), `MegaBlockTxResult` (`result.rs`); the pre-block call helpers and the pre-block budget (`eips.rs`); the activation block's check of the predeploys, the `SequencerRegistry`'s due changes and the commit of each pre-block step's state on its own in `apply_pre_execution_changes`, and the signal that a block is Satin's activation block (`MegaBlockExecutionCtx::satin_activation_block`); `MegaTransactionExt` (`helpers.rs`); the pre-block read of the L1 block info the transactions are priced against, every slot the pricing can read whatever the contract holds before the block (a deposit in the block may empty the fee scalars and turn the pricing to the overhead), committed as a read-only state of its own so a witness built from the committed states holds what op-revm and the executor read on the database itself (`l1_block_info.rs`); the block-hash and SALT-bucket records, emptied when the block starts and exported by the executor (`get_accessed_block_hashes`, `get_accessed_bucket_ids`) for the stateless witness (`evm/state.rs`); `SatinChainConfig`, the one parser of a genesis `config` object's Satin key, `satinTime`, in a provisional format (`genesis.rs`) |
+| `external/` | `ExternalEnvFactory`, `ExternalEnvs`, `SaltEnv`, `OracleEnv`, `EmptyExternalEnv`, the bucket hasher, `TestExternalEnvs`; `BucketMultipliers`, the per-transaction cache the SALT pricing hook reads through (`gas.rs`) |
+| `limit/` | the byte table every mechanism sizes a thing by; `LimitKind`, `LimitCheck`, `MegaLimitExceeded`, `LimitUsage`; the write records and the state growth a write and a frame start make, by the net change of the accounts and slots against their originals, a start's read off what revm did against its accounts as they stood before revm decided it (`StartBefore`), a `SELFDESTRUCT`'s rebuilt from the balance it moved, a creator's read off its nonce bump against the creator as it stood before revm decided the creation (`CreatorBefore`), and the parts of an account created in the transaction that its first effective destruction gives back (`DestroyedParts`) (`record.rs`); `AdditionalLimit`: the draws on a frame's three pools — data size, KV updates, state growth — and the transaction's limits held beside the pools, on what the transaction keeps — its body, its hints, its authorities' records and the accounts they created, a deposit's created caller, and what its frames keep, restored when a start's frame keeps nothing, one entry per start revm decided with a kept start's take-back credit and a creation's creator as it stood before revm decided it — the stops its frames return and the one the transaction reports, the exemption, and the settled transaction's history gas, history bytes and unspent reservoir (`limit.rs`); `EvmTxRuntimeLimits` (the data-size, KV-update and state-growth limits: a transaction cap each, the 98% share a child takes of what its parent has left, and an optional data-size frame cap; gas detention's two caps; the spec's, from `ProtocolLimits::for_spec`, in every context unless a tool or a test sets others); `LimitStop` and `decode_mega_limit_exceeded`, a limit stop read off a transaction's result for an RPC (`mod.rs`) |
+| `access/` | gas detention: `VolatileDataAccess` (`volatile.rs`); `Detention` — the reads committed, the compute limit and the spendable gas it holds each frame to, the classification of a crossing and of an answer, the compute figure across frames and what halts burn, and the volatile-access switch with its refusals and the decoder of a refusal's `uint8` access type (`detention.rs`) |
+| `system/` | the six contracts' addresses, code and ABIs, one module each; the interceptor dispatch and the value policy (`intercept.rs`); the `MegaAccessControl` interceptor steering detention's switch and the `MegaLimitControl` interceptor answering the caller's remaining compute (`control.rs`, `limit_control.rs`), and `SLOT_NUM_ACCESS_TYPE`; the Oracle's hint path, withheld from a frame whose volatile access is off (`oracle.rs`); keyless deployment as a native creation: the dispatch, the call's frame and its first run — the overhead, the nine rules and the charges of the creation's start (`keyless/dispatch.rs`), the creation's return into the call and the ABI answer (`keyless/settle.rs`), the Nick's Method transaction format and the error ABI (`keyless/tx.rs`, `keyless/error.rs`); the system-address transaction and its whitelist (`tx.rs`); the seven predeploys — the six contracts and the EIP-7997 factory — and the check of their code Satin's activation block makes (`predeploys.rs`); the `SequencerRegistry`'s due-change read and its `applyPendingChanges()` pre-block call, and the read of the live system address every transaction makes when it is validated, and the refusal of a transaction from it without the system shape (`sequencer_registry.rs`, `tx.rs`); `live_system_address`, the same read off a database, for a pool (`sequencer_registry.rs`) |
+| `constants.rs` | the provisional numbers (CPSB, slot and account state gas, CPHB, execution cap, contract and initcode size, data-size limits, the default detention caps, the compute bound they are held below, the pre-block calls' gas limit): the Satin gas schedule reads the state-gas and history numbers and the spec configuration reads the caps and the size limits; the pre-block calls read their gas limit; the rest are read by the limit mechanisms. The numbers are provisional until the economics sign-off |
+| `types.rs` | transaction, halt reason, error and envelope aliases, kept because Satin adds nothing to them (its halt set is op-revm's) |
+| `test_utils/` | `MemoryDatabase` (with the predeploys a chain that ran Rex6 holds, which Satin's activation block checks: `rex6_predeploys`, the registry alone with `sequencer_registry`, `SequencerRegistryRoles`), `ErrorInjectingDatabase`, `BytecodeBuilder` (with the programs that move value), `GasInspector`, `transact`, the EIP-7708 transfer log a test expects (`transfer_log`, `is_transfer_log`), the JSON `Scenario` format (one EVM per scenario, as a block runs); the execution-spec gate's neutral configuration (`neutral_cfg`, `neutralize_evm`, over `MegaContext::with_neutral_cfg`); the note a test's price guard leaves for the byte-price grid to count (`note_price_guard`); the witness recorder and the strict replay: a database and environments that record every read, the channel witness built from the states a node has (`CommittedStates`, the commit hook a node takes them with, `WitnessKeys`, `WitnessRecord::from_channels`), and a database and environments that serve exactly a record and refuse everything else (`witness.rs`) |
+
+### How Satin executes today
+
+- `MegaContext` wraps op-revm's context shape (`MegaTransaction` = alloy-op-evm's `OpTx`, `L1BlockInfo`) and adds the spec and the external environments.
+ Its journal is revm's own (`Journal`): what the transaction keeps of the data-size limit is drawn from the byte pool on each frame's gas tracker and counted on the common execution layer (see the contracts below), not beside the journal.
+ It keeps the configuration twice — the `MegaSpecId` view callers see and the `OpSpecId` view op-revm executes on — and writes both together.
+- The spec fixes part of the configuration, whatever the caller passes (`MegaContext::with_cfg`): the Satin gas schedule, EIP-8037 on, the EIP-2780 intrinsic cost on, `tx_gas_limit_cap` = 200,000,000, EIP-7708 on and not disabled, the chain-id check on (`tx_chain_id_check`, which the legacy engine pinned off), the contract size limit at 512 KiB, the initcode size limit at 1 MiB, and the fork's journal semantics (`legacy_journal_semantics` off).
+ That function is exported as `spec_cfg`: a node builds its `EvmEnv` through it, so what reads the env before an EVM exists (reth's gas estimation reads the execution cap) reads the configuration the EVM runs with.
+- What a transaction pool can decide without state is the handler's own `validate_env` and `validate_initial_tx_gas`, run on an EVM over an empty database (`validate_transaction_stateless`, `evm/validation.rs`).
+ `validate_env` is split at the state read of the live system address (`MegaHandler::validate_env_as`): the pool passes the address in, read with `system::live_system_address`, and the system address's nonce and code are left to the state, as every sender's are.
+ It reports the intrinsic gas by ledger (`IntrinsicGas`): regular, state (zero under EIP-2780, which charges the state a transaction adds when it runs), the body's history, and the floor.
+ op-revm includes a deposit that fails validation as a failed deposit rather than refusing it, so for a deposit or a promoted system-address transaction the error says it would fail.
+ Gas above the 200M execution cap goes to the EIP-8037 reservoir.
+- The Satin gas schedule (`evm/schedule.rs`) is Amsterdam's with four changes: the EIP-8037 state-gas entries are rebuilt from `MegaETH`'s own cost per state byte; the code-deposit history entry, zero upstream, is priced at the cost per history byte (`HISTORY_GAS_PRICED`), and a value call's history allowance at `HISTORY_ALLOWANCE_BYTES` of it; a child starts with 98/100 of its caller's reservoir and of each of its three pools (`GasId::reservoir_kept_percent`, `GasId::pool_kept_percent`); and a call or creation forwards at most `remaining − remaining × 2 / 100` of the caller's regular gas, Rex6's rule in place of EIP-150's 63/64 (`GasId::call_stipend_reduction`).
+ Every regular-gas entry is Amsterdam's, EIP-8038's state-access prices included, so creating state costs the access and the write in regular gas and the new state itself in state gas alone, as upstream.
+ The static opcode prices, which revm keeps in the instruction table, are Amsterdam's too (`satin_gas_table`): they part from the Osaka base's only in EIP-8038's 200-gas base of `EXTCODESIZE` and `EXTCODECOPY`.
+ It is built once per process, with a second copy that prices that entry at zero for a transaction exempt from history gas (`satin_gas_params_history_exempt`); the byte prices are an input (`evm/prices.rs`), so a measurement build can run other ones through the std-only `satin-price-override` feature or the `MEGA_SATIN_CPSB` / `MEGA_SATIN_CPHB` environment variables.
+ `crates/mega-evm/tests/satin/pricing-table.md` lists every entry next to Osaka's and Amsterdam's, what nine probe transactions spent, and what two of those probes spend with the bucket they write into crowded; a test renders it and compares it to the file.
+- The instruction table adds the Amsterdam opcodes the base spec gates off (`DUPN`, `SWAPN`, `EXCHANGE`, `SLOTNUM`), before the volatile-read wrappers go in; `CLZ` is gated on Osaka and needs no activation.
+ `SLOTNUM` pushes `BlockEnv::slot_num`, which the node supplies, and zero for a block that leaves it unset.
+- The precompile set is op-revm's Karst set with KZG point evaluation repriced to 100,000, carried as an alloy-evm `PrecompilesMap` so a node can add or replace an address (`MegaEvmFactory::with_dyn_precompiles_builder`).
+- `MegaEvm` runs transactions through `MegaHandler`, which wraps op-revm's handler, and implements revm's frame lifecycle itself; every `Host` and context method delegates to op-revm's context except the two instruction hooks that meter a completed write and a frame start, the block-hash read the Host records, the state-gas price the Host scales and the loads of volatile data the Host marks or refuses.
+ Satin's one divergence from op-revm on an ordinary transaction is the history gas it charges: `tests/satin/equivalence.rs` holds every baseline case to op-revm's total plus the history ledger, on op-revm's own state gas, logs and state, and pins what that ledger is made of; a later change that alters behavior on purpose updates that baseline.
+ A transaction that destroys an account it created diverges beside it by the state gas the destruction table gives back, which EIP-8037 does not (`test_a_creation_that_destroys_itself_diverges_from_op_revm`).
+- SALT pricing scales every EIP-8037 state gas charge by the capacity of the SALT bucket it lands in: `state gas = schedule entry x m`, where `m` is that capacity in minimum buckets (`evm/host.rs`).
+ A charge on a slot reads the slot's bucket, a charge on an account leaf reads the account's, and `m` touches the state dimension only — regular gas never scales.
+ A slot is charged by the `SSTORE` that fills a fresh one; an account leaf by a `CREATE`, `CREATE2` or value `CALL` that adds it, by the transaction's own recipient or the address a creation transaction deploys at, by an applied EIP-7702 authority (its account and its delegation indicator), by the beneficiary a `SELFDESTRUCT` moves a balance to, by the caller a deposit-like transaction creates, and by a keyless deployment's signer when the creation's nonce bump creates it and its deploy address; the bytes a creation deposits are charged in the deployed address's bucket.
+ The capacities come from the transaction's `SaltEnv` through `BucketMultipliers` (`external/gas.rs`), which reads a bucket once per transaction; the cache is cleared with the rest of the per-transaction state.
+ A system-originated transaction prices at the minimum bucket and reads no capacity at all, so a state change the protocol mandates cannot be priced out by the growth of a region it does not control; that is a transaction whose caller is the EIP-4788 system address, the sequencer's own system transaction — before or after the engine promotes it to a deposit — and every transaction run through a system-call entry point.
+ A failed capacity lookup reports nothing and records its cause the way a failed `sload` does; the transaction fails with that cause rather than settling at a price nobody chose.
+ At the minimum bucket every number is the schedule's own, which is why the op-revm baseline and the pricing table did not move when SALT pricing landed.
+- History gas prices the bytes a transaction appends to the chain, at `MegaETH`'s cost per history byte and never scaled by SALT — history bytes live in no bucket (`evm/history.rs`).
+ The byte table is the `limit` module's, the same counts the data-size limit meters, so a record's history bytes are its own data size and the two cannot drift apart: a transaction body of 310 bytes (110 for the envelope and one 40-byte record for each of the five writes every transaction makes — the sender's account and the four accounts its fees are credited to), one byte per calldata byte, 20 per access-list address and 32 per key, 101 per EIP-7702 authorization, a log's 32 for its address and 32 per topic plus its data, one 40-byte record per kept account or storage write, and one byte per byte of deployed code.
+ The body, the applied authorities' records and the record the transaction's own frame makes are charged before execution: the body where revm builds the transaction's gas (`MegaHandler::tx_gas`), as intrinsic gas — the reservoir pays it first, it is not held to the execution cap, and revm's runtime out-of-gas fallback, which rebuilds the gas through the same phase, keeps it charged — and the two record charges in pre-execution, where the records are made; the first frame carries its record's charge on its input (`charged_start`), which the shared first-frame settlement gives back when it fails.
+ A gas limit that cannot cover the body is rejected at validation rather than included as an out-of-gas.
+ Every other charge is made where the record is: the completed-write hook charges a storage write's record, a log's and a `SELFDESTRUCT`'s records at the end of its opcode, and the frame-start hook charges the caller of a `CALL`, `CALLCODE`, `CREATE` or `CREATE2` for the records the frame it starts makes, out of what the caller kept rather than out of what it forwards, and declares the frame's own on the start (`FrameStart::charge`), which the fork refunds when the frame fails.
+ What a frame does not keep comes back, at the same price, to whoever paid it.
+ The pairing is per record: per transaction the two totals part at three sites, each by decision — an Oracle hint's payload is data size that is never history, an EIP-7708 transfer log is data size that is never history either, and the body's five records are an upper bound, so a transfer to the block beneficiary or a fee vault pays a record the body already bound.
+ A deposit, a transaction the protocol itself produced and a system call pay no history at all (`MegaContext::prices_history`), and an exempt transaction runs a schedule that prices a deposited byte at zero, so the one history charge revm makes itself is off it too.
+ The EIP-7623 calldata floor is still computed and validated.
+ At the spec's byte prices it never raises the gas used of a transaction that pays history, because history charges the same bytes at a higher rate; it can raise an exempt transaction's, and it binds the figure a block counts on its execution ledger, `max(regular, floor)`.
+- A value-transferring `CALL` or `CALLCODE` below the transaction's own frame grants the frame it starts a history allowance of 160 bytes — one three-topic event carrying a word — at the cost per history byte, so a `receive()` hook reached through Solidity's `transfer()` can still emit an event.
+ It is not gas: it never enters the frame's `Gas`, only a log's charge may draw on it, and what it pays for is on no ledger, because no pool of the transaction's gas paid it.
+ The history bytes a transaction reports count those bytes all the same, so the byte column and the history gas column part by exactly what allowances paid.
+ The transfer log of the value that granted the allowance draws nothing from it: the log costs no history.
+- EIP-7708 is on: every value movement — the transaction's value, a value `CALL`, a creation's endowment, a `SELFDESTRUCT`'s balance moved to another account — emits a `Transfer(from, to, amount)` log from `0xff…fe`, which revm journals itself, without a `LOG` opcode, and the receipt carries in execution order among the contracts' own logs.
+ A `CALLCODE`, a call to itself and a transaction's value to its own sender move nothing to another account and log nothing; a deposit's value is logged and its mint is not; a destruction to itself burns the balance of an account created in the transaction without a log, because the base spec predates EIP-8246 and this revm emits no `Burn` log.
+ A transfer log is data size like any log, counted by the rule a `LOG3` of one word is — 160 bytes, `TRANSFER_LOG_SIZE` — and nothing else: it is no write record and pays no history gas, because Ethereum prices it at nothing and it is not a byte the transaction chose to write.
+ It is counted where the value moves, on the pool of the frame whose journal checkpoint holds the move: a frame start's log with its records, on the started frame; a `SELFDESTRUCT`'s with its records once the opcode completed, so a crossing stops the destructing frame and its checkpoint takes the move back.
+ A frame start's records and log are read off what revm did, in `MegaEvm::frame_init`: the start's accounts on its frame — a call's caller and target, a creation's created account — are read before revm decides the start, with a journal mark (`Accounts::start_before`), and again once it did, each account's record by its change since, one account of state growth for each that was empty and is not, and the transfer log revm journaled since the mark (`Accounts::start_made`), drawn on the pool the frame starts with (`AdditionalLimit::count_start`): a frame revm built ends with the stop before any instruction, in `frame_init`, and its revert takes back the move and the log; a success revm gave without building the frame — a call to an account with no code, to a precompile that answers — gives way to the stop on its untouched gas, and its committed move and log are taken back to the mark (`take_back_a_stopped_answer`).
+ An answer that failed kept nothing, revm having taken back what its start moved, and is held to nothing: its result is revm's, so a value call to a precompile that fails burns its forward as any failed precompile does, whatever its value transfer would have counted.
+ It is not held to the transaction's limits either, having kept nothing: a deposit whose created caller alone stands over a state-growth limit of nothing, which only a tool's limit sets, and whose first frame is such an answer ends as a failed deposit, not with the stop a success answer there gets (`tests/satin/state_growth.rs`).
+ A start revm refuses on its caller's account moves and writes nothing: a call it answers `OutOfFunds` counts nothing and is stopped by nothing; it was charged nothing at its opcode, which prices a start's records from the journal's state and sees the caller cannot fund the value.
+ A creation it would answer before bumping its creator's nonce — an endowment the creator cannot fund, a creator whose nonce is at its maximum — is refused by the `CREATE` and `CREATE2` opcodes themselves, before the start's hook under EIP-8037, and otherwise reaches the hook without a created address, for which it prices no record, so a plain run charges and counts nothing for it; only an inspector that rewrites the creation's input after the hook reaches revm's refusal, which bumps nothing and so counts nothing: the declared part of what the opcode charged comes back with the refused start, and the history of the creator's record, which is not declared, stays charged.
+ A creation onto an occupied address, which revm fails after the nonce bump, is held to nothing at its start: it fails on the collision, its records and log go with the failure, and the nonce record is counted on the creator once the creation returned, held to the creator's limits.
+ The one decision taken before revm's is gas detention's answer to a precompile whose price crosses the compute limit, given without running it (`hold_precompile`): it moves nothing, so it is held to the price alone, the compute stop, whatever the records its value transfer would have made; it is not given to a value call whose caller cannot fund the value, which revm refuses first.
+ A start past the call-stack limit, of any scheme or a creation, is answered by the depth guard with revm's own `CallTooDeep` before it is counted.
+ A start's log is the one revm journaled for it; `tests/satin/transfer_logs.rs` pins every site, and a unit test in `evm/history.rs` holds each against the same transaction with the switch off: the same gas on every ledger and the same state, 160 bytes of data size per log.
+- The data-size limit holds a transaction to `EvmTxRuntimeLimits::tx_data_size_limit` and every frame to a budget: the transaction's own frame gets what its body leaves, and a child 98% of what its parent has left, under an optional frame cap.
+ A frame's budget is a pool on its gas tracker (`limit::DATA_SIZE_POOL`; the KV-update and state-growth budgets are the other two pools): the transaction's tracker starts with what the body and the counts made before the frame leave (`AdditionalLimit::first_frame_pools`), revm hands the first frame the whole of it and every child the schedule's share of its caller's (`GasId::pool_kept_percent` = 2, so a child gets 98%), capped where the caller suspends (`cap_the_shares`: the frame cap, and a frame's remaining clamped to its budget, so a negative net never enlarges a child's share), and settles a returning child's pool as it settles the reservoir; the transaction's limit is held beside the pools on what the transaction keeps (`AdditionalLimit::usage`).
+ In each counted dimension the frame budget is tested before the transaction limit: a crossing of both names the budget, and the transaction limit is named only when the budget is not crossed — after Oracle hints used what the transaction had left, or when a deposit-like transaction's created caller stands on a state-growth limit of nothing; the budgets of the frames on the stack add up to what the transaction has left, so otherwise a frame that crosses the transaction limit crosses its own budget too.
+ The bytes are the byte table's, counted where they are made: the body before any frame, the authorities' records before the first frame, a frame start's records when it starts, held to the limits once revm decided it (none for a start revm refuses on its caller's account), a storage write, a log or a `SELFDESTRUCT`'s records (the account it clears and its beneficiary) once the opcode completed, an EIP-7708 transfer log with the frame-start records or the `SELFDESTRUCT` that moves the value, deployed code once `return_create` has made every charge for it and before it commits the creation (`MegaContext::admit_code_deposit`; code starting with `0xEF` or over the code-size limit, and a creation that cannot pay a part of its deposit, the history included, fail the creation alone and are not counted), an Oracle hint before it is forwarded (one that would cross the transaction's limit is neither counted nor forwarded, and its call is answered with the stop, so the transaction keeps none of its bytes).
+ A frame that crosses its budget or the transaction's limit reverts alone, and its caller resumes (the contracts below).
+ Every `MegaContext`, a bare one included, runs under its spec's limits, and a block executor installs the same (see the protocol limits below): Satin holds each transaction to `TX_DATA_LIMIT` and the block to `BLOCK_DATA_LIMIT`, 12.5 MiB each.
+ The block's data size is a packing budget (see the block executor below).
+ `tests/satin/data_size.rs` derives where the stop gives way to out-of-gas: a top-level fresh `SSTORE` is counted at 152,306 gas, and keeping its record costs its 3,520 history on top.
+- A limit stop names one of four runtime dimensions, the `kind` of `MegaLimitExceeded` (`LimitKind`), with the discriminants the legacy engine encoded: data size (0), KV updates (1) and state growth (3), each drawn from a pool of the frames' gas trackers under a transaction limit, and compute gas (2), gas detention's stop.
+ An operation that crosses more than one counted dimension stops on the first of data size, KV updates, state growth (`limit::COUNTED`); compute is decided at the regular charge, before the write is counted.
+- The KV-update limit holds the write records a transaction keeps — its KV count, one record per kept account or storage write: an account's while its nonce, balance or code differs from what the transaction loaded, a slot's while its value differs from its original, each taken back by a write that returns the account or the slot and with a failed frame — to `EvmTxRuntimeLimits::tx_kv_update_limit` (`TX_KV_UPDATE_LIMIT`, 500,000) and every frame to 98% of what its parent has left, on the KV-update pool (`limit::KV_UPDATE_POOL`); a crossing reverts the frame with `MegaLimitExceeded(1, limit)` (`tests/satin/kv_updates.rs`), and the count is reported, in the outcome's usage and the block's.
+ The sender's account is the body's, not a record, and so are the fee credits the settlement makes, so a transaction that writes nothing counts none; a write execution makes to a fee account that is not the sender is a record like a write to any other account.
+ A record is forty bytes of data size, counted and taken back with them, so `KV × 40 ≤ data size` holds after every instruction (`tests/satin/write_records.rs`), and at the production data-size caps a transaction or a block keeps at most 327,680 records.
+ History gas prices every record.
+ At the spec's numbers 500,000 records weigh 20,000,000 bytes, more than `TX_DATA_LIMIT`, so the data size binds first; the KV check is still made.
+ An EIP-7702 list that would keep more records than the limit allows is skipped whole (`hold_authorization_list` in `evm/execution.rs`, see the authorization list below).
+- The state-growth limit holds the net count of new accounts and new slots a transaction keeps to `EvmTxRuntimeLimits::tx_state_growth_limit` (`TX_STATE_GROWTH_LIMIT`, 1,000) and every frame to 98% of what its parent has left, on the state-growth pool (`limit::STATE_GROWTH_POOL`); a crossing reverts the frame with `MegaLimitExceeded(3, limit)` (`tests/satin/state_growth.rs`), and the count is reported, in the outcome's usage (`LimitUsage::state_growth`, `max(net, 0)`) and the block's.
+ One unit rises where EIP-8037 charges the state gas of one, counted where the record of the same write is (`limit/record.rs`): an `SSTORE` from an original and present zero to non-zero, and falls on the write from an original zero back to zero; a value transfer that moves value its caller can fund to another account empty under EIP-161 (a value `CALL`, the transaction's own value), a creation at an empty address (the transaction's own included), both counted on the started frame and read off what revm did: an account the start found empty and left not empty (`Accounts::start_made`; `FrameStart::of` loads a creation's address first where EIP-8037 is off and the opcode did not); a `SELFDESTRUCT` moving a balance to another account that does not exist; a creator's nonce bump that creates the creator, a keyless deployment's signer, counted with the creator's record on the creating frame once the creation returned (`Accounts::creator_counted`); and, before the first frame and on the transaction, each authority an applied authorization list created and the caller a deposit-like transaction created, which no failure takes back (`AdditionalLimit::count_authorities`, `count_created_caller`).
+ A fee credit, a `CALLCODE`, a value call to the calling account, deployed code and a delegation indicator are no rise; a failed frame's net goes with it.
+ An applied EIP-7702 authority counts as created where revm charged it as a new account — empty, loaded as not existing and untouched when the application reached it — read after the application as loaded as not existing, empty at the transaction's start and touched first by the application (`applied_authorities` in `evm/execution.rs`), so on a journal that runs several transactions unfinalized the count follows revm's charge, the flag of an earlier transaction's touch included (see the destruction table below).
+ EIP-8037 still charges state gas for exactly the state a transaction adds, at the price of the SALT bucket it lands in; the count is what stops the 1,001st slot, which the gas a transaction can pay would not.
+ An EIP-7702 list that would create more accounts than the limit allows is skipped whole, as one over the KV count is (`hold_authorization_list`).
+- The first effective `SELFDESTRUCT` of an account created in the transaction applies the destruction table (`limit/record.rs`, `DestroyedParts`; the completed-write hook in `evm/host.rs`): every part of the account the transaction made comes back to the destroying frame, whichever frame paid — the leaf when the transaction found no account there at its start (`Accounts::was_absent_at_start`: its original info empty, and the database answered none, `is_loaded_as_not_existing`, or an earlier transaction on the same journal destroyed it, which revm's record of this destruction names `LocallySelfdestroyed`), with its new-account state gas, its unit of state growth and the account's write record; the code deposited at it, with its state gas, its data size and its history; each slot it made non-zero from an original of zero, with its state gas, its unit and its record.
+ A part that existed at the start, such as the leaf of an address funded before the transaction or one empty under EIP-161 with storage, is an ordinary deletion: no refill, no fall, and its write record stands.
+ Every fact is the journal's: an account revm created in the transaction (`is_created_locally`), the first destruction of one (`SelfDestructResult::previously_destroyed` false), the account's original info and each slot's original value; a slot of an account created in the transaction that the journal does not hold yet loads as zero, so the slots it gives back are the ones it made non-zero, in key order.
+ revm's flags of an account the database answered none for and of a touched account are set at the account's first load or touch on the journal and outlive the transaction that set them on a journal that runs several transactions without finalizing; a fact about this transaction's start is read with what the journal records of this transaction: its original info, its entries (`JournalEntry::AccountDestroyed`'s status, `AccountTouched`), and the transaction id of what it loaded.
+ What the parts take back is in the same check as what the operation adds, so the beneficiary's record, its transfer log and its unit are held after the give-back; once the check passed, each part's state gas is refilled at the price it was charged, re-priced through `state_gas_price` at the site it landed on, with the history of the records and the schedule's history of the code, before the operation's own records are charged.
+ The refills follow the refill order, the frame's spill first; a failure of the destroying frame, or of a frame that contains it, takes back the mark with the journal and the give-back with the frame.
+ From the mark until the transaction ends the account counts nothing more (`Accounts::is_destroyed`): its nonce no longer is what the transaction loaded, so no write to it makes or takes back its record and a value moved to it adds no account, and an `SSTORE` of one of its slots counts nothing; the pricing hook prices every state charge on the account at nothing, so such an `SSTORE` neither charges nor refills fresh-slot state gas and code its own constructor deposits after destroying it (through a `DELEGATECALL`) is charged no state gas, whatever gas the frame holds, its data size and history standing; the table's own give-back prices the parts outside that rule (`MegaContext::priced_state_gas`).
+ A slot of the account loaded before the creation, which only a tool's load reaches, keeps the value it held at the start: the deletion refills nothing for it and makes its record while it still holds that value.
+ The account's logs stay counted.
+ The neutral configuration counts the table as the spec's does and prices state gas as the fixture's fork does, which gives none back for this destruction (`MegaContext::destruction_table_prices_state_gas`).
+- The limits that change a result are protocol values fixed per spec, as the legacy engine's were: `ProtocolLimits::for_spec` (`block/limit.rs`) is the one table of them, keyed by `MegaSpecId`, with one arm, `SATIN`, every field written out.
+ It holds the per-transaction limits (`tx_runtime_limits`, an `EvmTxRuntimeLimits`: data size per transaction 13,107,200, KV updates per transaction 500,000, state growth per transaction 1,000, no frame cap beyond the 98/100 share, detention's two caps 20,000,000 each) and the block's three packing budgets, data size 13,107,200, KV updates 500,000 and state growth 1,000; the values are provisional with the constants.
+ No chain configuration carries them: they are not fork params, a genesis file names none, and a node passes none of them; a test holds them to what the removed load-time check held a chain's values to (none zero, the data size above `TX_BODY_SIZE`, the detention caps below `MAX_TX_COMPUTE_GAS`, 199,987,900, so detention binds), and `tests/block/l1_attributes.rs` holds the block's L1 attributes deposit to them.
+ Three layers keep three scopes: `ProtocolLimits::for_spec` the consensus values; `EvmTxRuntimeLimits` what one EVM runs under, the table's by default (`Default` is the default spec's), which a tool or a test may replace; `BlockLimits` the builder's policy, which only tightens.
+ `MegaContext::new` starts under its spec's limits, so an EVM from `MegaEvmFactory` (an RPC call, a simulation, a tool) and a bare context run under the limits block execution would hold their block to without being told; `MegaEvmFactory::with_tx_runtime_limits` and `MegaContext::with_tx_runtime_limits` are the explicit opt-outs, for equivalence, tools and tests.
+ The block executor reads the table for the spec its EVM executes, installs `tx_runtime_limits` on the EVM at construction and again before every transaction, and holds the block to its packing budgets; `MegaBlockExecutor::with_protocol_limits`, which exists only under `cfg(test)` or `test-utils`, holds a block to other limits, for tests and for `mega-evme --override.limits`.
+ The block's gas limit is the executor's state (`BlockLimiter::block_gas_limit`), taken from the block environment; no policy carries one.
+ The node's block context carries only building policy (`BlockLimits`): a transaction's declared gas, the encoded sizes and the data-availability sizes, which only a builder applies and never to a deposit, and caps on the three packing budgets that `BlockLimits::within` holds below the protocol's, so a policy tightens and never loosens; its default restricts nothing, and a validator leaves it so.
+ A builder's policy changes which transactions it packs, never what a packed block computes (`tests/block/building_policy.rs`).
+ Satin carries no fork parameter: the `SequencerRegistry`'s roles are what the registry the legacy forks left holds.
+ A genesis file's `config` object carries Satin as one key, `satinTime`, and every reader — a node, a stateless validator, a genesis generator, `mega-evme --genesis` — reads it with `SatinChainConfig::from_genesis_config` (`block/genesis.rs`), which refuses any other key starting with `satin`, the registry, `satinInitialFromBlock` and limit keys of the format's earlier versions among them, a value that is not a 64-bit integer, and a schedule `validate_schedule` refuses; the key format is provisional.
+- The protocol's own work is held to no per-transaction limit: a system-originated transaction (`system::is_system_originated`) and a system call — the pre-block calls among them — run under the layer's sticky exemption (`AdditionalLimit::exempt`), stamped before the body is counted, which every stop the layer hands out consults (`AdditionalLimit::crossed`), answering that nothing was crossed: no data-size limit and no frame budget stops them.
+ It is the set history gas exempts, for the same reason: the protocol's maintenance must not fail on a resource limit.
+ The exemption covers the KV updates and state growth beside data size.
+ What they use is counted all the same and reported, in the outcome's usage and in the block's counters, as a deposit's is.
+ A block cap never refuses a pre-block call, which is no transaction of the block; a Mega System Transaction the block's packing budgets and the builder's policy never refuse, while the block's gas limit and the data-availability footprint hold it as any legacy transaction, because the block decides on the envelope (see the block executor below).
+ A user's deposit is not system-originated and is held to every per-transaction limit.
+- Gas detention caps the compute a transaction may spend once it read volatile data — the block environment, the block beneficiary's account, the Oracle's storage — at its compute at the read plus a cap, a runtime limit of 20,000,000 by default (see Gas detention below).
+ It holds a frame's spendable gas with the revm fork's withheld part, which every reader of the frame's gas but a regular charge counts, so a detained transaction runs as it would without the read until a regular charge needs the withheld part.
+ That crossing stops the frame that makes the charge, with `MegaLimitExceeded` of kind compute, and its caller resumes held to what the limit leaves; every other out-of-gas halts as it would without the read.
+- `MegaBlockExecutor` runs a block: alloy-evm's `BlockExecutor` over a `MegaEvm`, mirroring what alloy-op-evm's `OpBlockExecutor` does for an OP chain.
+ It applies the three block rules of the Karst base — an activation block admits only deposits, the data-availability footprint is a block limit reported as the block's blob gas, and the L1 block info is read by the first transaction that prices against it — holds every transaction to the spec's `ProtocolLimits` and the builder's `BlockLimits`, and fills `BlockGasCounters`.
+ The block's data-size limit, known only after execution, packs the transaction that reaches it and then refuses every later transaction before it runs.
+ It never refuses a deposit or a Mega System Transaction: it is a packing budget for the transactions the builder chooses, and neither is chosen; both still count towards it, so the transactions after them find the room they used.
+ Nor does the builder's policy refuse either.
+ The block's KV-update and state-growth limits (`BLOCK_KV_UPDATE_LIMIT`, 500,000 write records, and `BLOCK_STATE_GROWTH_LIMIT`, 1,000 new accounts and slots) are packing budgets of the same kind, checked after the data size and in that order (`BlockLimiter::pre_execution_check`), so a block full on several names the first; the transaction that reaches one is packed, every later ordinary one is refused before it runs, and neither refuses a deposit or a Mega System Transaction, which still count; the block's gas limit does not stand in for the state-growth budget (`tests/block/limits.rs`, `tests/block/system_tx_budgets.rs`).
+ No block limit holds the execution, state or history ledger: they are counted and reported.
+ A deposit is the envelope's (`is_deposit` in `execute`): a Mega System Transaction is a legacy envelope, which an activation block refuses and which the data-availability limits and footprint hold like any non-deposit transaction, but the block decides before the engine promotes it that it is one (`MegaBlockTxResult::is_system_transaction`: a legacy call of the system shape from the live system address, read with `live_system_address` and `classify_system_transaction`), and the packing budgets and the builder's policy do not refuse it; the commit-time check reads the same flag.
+ alloy-evm's `commit_transaction` cannot fail, and its contract is that an outcome commits before the next transaction executes; a builder that executes candidates and chooses among them commits through `commit_transaction_outcome`, which checks the counters again and refuses what no longer fits, and a debug build asserts the same check in `commit_transaction`.
+ The checked commit also refuses an outcome whose sender's nonce or balance — the system address's, for a system-address transaction — another commit moved since it executed (`MegaBlockExecutionError::StaleOutcome`, an internal error; the executor reads the sender's account before every transaction into `MegaBlockTxResult::{sender, sender_nonce, sender_balance}`), and a debug build asserts it in `commit_transaction`; any other state a candidate read is the builder's to keep fresh, which the system-transaction-first flow relies on (`tests/block/stale.rs`).
+ `apply_pre_execution_changes` commits each pre-block step's state on its own, in order, read-only entries included — that sequence of committed states, with the included transactions' and the exports, is the witness a stateless client needs, and a node collects it with a commit hook on its `State` (`State::set_state_hook`), which receives each state whole, where the block's transitions keep only what a state changed; after the two EIP calls it checks the seven predeploys in Satin's activation block alone (see below), applies a role change the `SequencerRegistry` has due in the block (see the system calls below), and last commits the L1 block contract's account and every slot the transactions can be priced against (`L1_BLOCK_INFO_SLOTS`: 1, 3, 5, 7 and 8) as read-only entries (`read_l1_block_info`), because op-revm and the executor read them on the block's state rather than through a transaction's journal, so they land in no transaction's state.
+ The overhead (5) is in the entry whatever the Ecotone scalars hold: op-revm reads it when the scalars it finds at the block's first non-deposit transaction are empty, which a deposit earlier in the block decides, so an entry listing it only under empty pre-block scalars would leave a read no state names (`tests/block/witness/state.rs`).
+ The pre-block step does not read the live system address: the executor reads it before every non-deposit transaction, as above, and every transaction reads it itself when it is validated (see below).
+- Satin deploys, upgrades and seeds no contract: it runs on a chain that ran the legacy forks, which installed the six MegaETH system contracts at the versions Satin runs (the Oracle at v2.0.0, Rex5's, and the `SequencerRegistry` at v2.0.0, Rex6's), and whose genesis OP's tooling gave the EIP-7997 factory.
+ The block in which Satin activates reads the seven in order, and each must hold exactly Satin's code, whatever its nonce, balance and storage (`check_system_contract`, `system/predeploys.rs`); anything else — no account, no code, an older version, other code — refuses the block with one error naming the address and both code hashes (`MegaBlockExecutionError::UnexpectedSystemContractCode`, a verdict on the block), and each read is a read-only pre-block state.
+ The node says which block that is (`MegaBlockExecutionCtx::satin_activation_block`, off by default), from its schedule and the parent's timestamp as it sets `no_user_tx_activation_block`; no other block reads the seven.
+ A test or a tool that runs a Satin block on a state of its own puts them there in the shape Rex6 left them (`test_utils::rex6_predeploys`, `MemoryDatabase::rex6_predeploys`, `SequencerRegistryRoles`).
+ Three of the six system contracts have interceptors (`system/`) — `MegaAccessControl` and `MegaLimitControl` answer, the Oracle's forwards a hint and lets its bytecode run, or answers a hint that would cross the data-size limit with the stop — and `KeylessDeploy`'s `keylessDeploy` is taken by the keyless dispatch before interception.
+ A `CALL` or `STATICCALL` is dispatched on its target address, then on the four selector bytes of its input; an unknown selector is not intercepted and runs the contract's own bytecode.
+ `MegaAccessControl` steers detention's switch for the frame that calls it (see Gas detention), `MegaLimitControl.remainingComputeGas()` answers the compute the calling frame could still spend, and the Oracle forwards a `sendHint` payload to the node's oracle service.
+ `remainingComputeGas()` answers the lesser of two figures, read when the call reaches the interceptor, after the calling opcode charged its own costs: the caller's own regular gas with the gas the call forwarded counted back (the answer returns it untouched, so this is what the caller holds when the call returns), and, once a read of volatile data set a limit, what the limit leaves the transaction (`Detention::allowance`).
+ That is the caller's spendable regular gas before the forward, which detention caps; a transaction that calls the contract directly hears its own frame's regular gas, or detention's cap when it is detained from its start (its sender is the block beneficiary).
+ The figure is regular gas only: the reservoir is not in it, so a transaction above the execution cap hears at most the cap's share.
+ Of the legacy engine's figure one property carries over, that the gas a call forwards is not counted; the figure itself departs from it, because the legacy one came from a separate compute ledger, with per-frame budgets of 98/100 of the caller's remaining compute under the transaction's compute limit, and could exceed the caller's gas, where here compute is regular gas and the answer is at most the caller's own.
+ A `sendHint` from a frame whose volatile-data access is off — its own switch or one above it — is dropped: not forwarded and not counted, while the call runs the bytecode as any other.
+- The Oracle's storage is read through the oracle environment: an `SLOAD` in the Oracle's own frame (a load whose owner is the Oracle) loads the slot through the journal, then asks `OracleEnv::get_oracle_storage`, and gets the environment's value when it answers — even over a value the Oracle's frame stored earlier in the transaction — and the loaded value when it answers `None`; `EmptyExternalEnv` always answers `None`.
+ A node that replays a block without the service must price and witness it as the node that built it did, and it cannot tell which source the building node read, so nothing may depend on the source: every such read is priced as a cold access, however often the slot was read, and the slot is loaded on both paths, so afterwards it is warm for the frame's `SSTORE` and it is in the transaction's state, which a stateless witness is built from.
+ A frame whose regular gas, the part detention withholds included, cannot pay the cold access reads nothing and asks nothing, and a refused read asks nothing either; a detained frame that holds the gas but may not spend it does ask, and the charge then stops that frame at the compute limit.
+ It is a volatile read for detention, under the Oracle's cap, and a hint reaches the service synchronously as `sendHint` is called, so a read after a hint finds the service told.
+ A system call, a pre-block call among them, asks no service: its Oracle read answers the chain's slot and records nothing (`MegaContext::is_system_call`, set in `on_new_system_call` and cleared by the next transaction), so a chain whose EIP-2935 or EIP-4788 code reads the Oracle still replays from its witness.
+ Every such read by a transaction is recorded with its answer on the transaction's outcome (`MegaTransactionOutcome::oracle_reads`, the context's `OracleReadRecord`, emptied before every transaction and system call), which is where a node building a stateless witness takes the oracle answers of the transactions it includes from.
+- A `keylessDeploy(bytes,uint256)` call a transaction makes is a native keyless deployment (`system/keyless/`): the pre-EIP-155 creation it carries is deployed as a `CREATE` of its signer, at the signer's Nick's-Method address.
+ The dispatch (`keyless::is_dispatched`) runs in `frame_init` before interception, and revm builds the call's frame as any call's: on the contract, at depth 0, on revm's frame stack, with its own journal checkpoint and gas.
+ No code runs in it: its actions are made by hand, its first where revm built the frame (`keyless::start`, in `frame_init`) — a refusal ends the frame before it runs, as the stop of a start does, and the creation is set on the frame's interpreter — and its answer once the creation returned into it (`keyless::answer`, in `frame_return_result`), set on the interpreter the same way; revm's frame run, plain or inspected, returns an action set on a frame before it runs.
+ An inspector sees the frames the deployment is made of: the call, started and ended as any call's, and the creation as its child, one journal depth below; the call's interpreter is handed to no `initialize_interp` and gets no `step`, since revm's inspected run returns an action set on a frame before any `step` and skips `initialize_interp` for a frame built with one, and a refused call is seen to start and end and nothing else.
+ It charges the fixed overhead, which pays for decoding the transaction and recovering its signer, and holds the call to the legacy engine's nine rules and error ABI in the legacy engine's order, so a call several rules refuse reports the legacy engine's error.
+ Among the rules it charges the signer's account when the creation's nonce bump creates it, SALT-priced state gas, where the legacy engine charged it; after every rule, what the `CREATE` opcode charges its frame: its regular gas (the schedule's `create` entry and EIP-3860's cost per word of init code), the created account, SALT-priced state gas, and the creation's two write records.
+ It then starts the creation at depth 1 with `CreateScheme::Custom` and `gasLimitOverride` capped to what the call has left, which must still cover the signed gas limit.
+ It is held to its limits as any depth-0 call is, running as the signer from the first run on: the creation's start charge and share of its pool are the call's, and the signer's nonce record is counted on the call's pool once the creation returned, at the settlement (`keyless::settle`), as a `CREATE`'s creator's record is on the creator.
+ The creation returns into the call through `frame_return_result`, which reads the creation's outcome before revm merges it (`keyless::returning`) and takes the nonce back after (`keyless::settle`), before the call resumes, and the call answers in the ABI on its resume.
+ The frame is built on the contract as its target: the contract's account, which the transaction loads with its code to start its first frame, is touched by a call that returns, as a call's target is; a witness holds the account and its code for any transaction to the contract, so the frame adds nothing to it.
+ A call carrying value is refused `NoEtherTransfer()`, having paid the overhead, before revm builds its frame, so no value moves and nothing its start would write is counted.
+ The dispatch is by address and selector, whatever the address holds: where the state holds no contract code, the frame is built on the contract's own, which never runs.
+ A stop of the call itself — its own charges past detention's limit, or a limit the creator's nonce record crosses on it — reverts it with the stop and takes the deployment back, the signer's nonce included; otherwise the call succeeds with the deployed address or the error the creation failed with, a limit's stop the creation crossed included.
+ `ORIGIN` and `GASPRICE` in the init code are the transaction's, and `gasUsed` is what the creation spent from either pool, the same below and above the execution cap.
+ Rule 4 (signer nonce at most 1) counts real nonces: the creation's bump stands from 0 to 1, which is the replay barrier.
+ From nonce 1 the settlement sets the nonce back, whether the deployment succeeded or failed, only when the creation's bump is the last nonce change the deployment made, so the signer stays at 1, as in the legacy engine: no number of failing calls — the call is permissionless and the signed transaction public — gets the signer's deployment refused, and a resubmission of one that deployed is refused `ContractAlreadyExists()`.
+ The bump's write record and its history go back with it, unless the creation succeeded and moved value out of the signer, whose account then keeps a write of its own.
+ A signer whose own code spends a nonce in the constructor that survives it keeps every bump, ends above 1, and every later deployment of it is refused `SignerNonceTooHigh`; on a default configuration only a delegated signer's code can do that, with a `CREATE` or `CREATE2`, successful or not.
+ The nonce is never moved back under a later bump, because a later bump may stand for an account.
+ `ParentBudgetExceeded`, `InvalidTransaction`, `InsufficientComputeGas` and `InternalError` are gone from the Rust enum and from `IKeylessDeploy.sol`, which changes no deployed byte: the sandbox's preflight and validation are gone, the overhead is regular gas a call that cannot pay runs out of, and a failed read or SALT lookup fails the transaction with its cause.
+ `tests/system/keyless/interface.rs` holds the generated binding's errors to the set `docs/spec/system-contracts/keyless-deploy.md` lists for Satin.
+- The system address may send transactions the protocol pays nothing for (`system/tx.rs`): a legacy transaction from it to a whitelisted contract is validated — the chain id, which it must carry and which no configuration switches off, the nonce, EIP-3607 — and promoted to a deposit by the engine as it runs it (the block decides on the legacy envelope: see the block executor above), and the account a deposit-like transaction creates for its caller is charged the account-creation state gas once.
+ Which address that is, the `SequencerRegistry` says, and the transaction reads it itself (`system::load_system_address`, called first thing in `MegaHandler::validate_env`): every transaction, whatever its shape, loads the registry's account and `_currentSystemAddress` with revm's own loads, without the registry's code, and the two stay warm for the rest of the transaction, as EIP-3651 leaves the block beneficiary, so what a transaction pays never depends on its envelope.
+ A transaction of the system shape — a legacy call to a whitelisted contract, tested on its own fields — whose caller is that address is a system-address transaction.
+ A transaction from that address without the system shape is invalid (`system::SYSTEM_ADDRESS_WITHOUT_SYSTEM_SHAPE`, an `InvalidTransaction::Str`, so a pool and a block reject it, and op-revm includes a deposit, which never has the shape, as a failed deposit); every other sender is an ordinary one, an address a rotation retired included.
+ The read is an untouched entry of the transaction's state, which a commit skips, so it moves no state root; the comparisons with op-revm and Ethereum take it out first (`test_utils::take_system_address_read`).
+ The Oracle's `onlySystemAddress` tests the sender alone, so the refusal is what keeps the system key's other transactions, an L1 deposit from it included, from writing the Oracle; the legacy engine refused them with an error that is not a transaction's, so a deposit from the system address left its block unexecutable.
+ Nothing inside a block can change the address after the block's pre-block call — a change is scheduled for a later block and applied by that block's pre-block call — so every transaction of a block reads the address the pre-block step left, a rotation governs its activation block, and an EVM a node builds outside block execution (an RPC call, a trace replay) reads the one in the state it runs on without being told.
+ The read names no address unless the registry holds the code this engine requires (v2.0.0) and a non-zero address, so an absent, foreign or empty registry promotes nothing; in block execution Satin's activation block refuses a chain whose registry does not hold the code, and a later block runs on the state it is given.
+ It is a read of the transaction's own, so the slot is in every transaction's state and witness, not in the pre-block witness.
+- A system call runs as EIP-8037 has it: at most 30,000,000 of its gas limit is regular gas, which is what `GAS` reads inside it, and the rest is its state-gas reservoir, which its state writes draw first before spilling onto the regular budget.
+ The split is the handler's (`MegaHandler::tx_gas`, through which revm builds a system call's gas on both system-call paths), for every system call whatever the configuration (`MegaContext::splits_system_call_gas`); the neutral configuration leaves a system call's gas whole for both forks, as revm's runner does, and no state fixture makes a system call.
+ What a system call left of its reservoir is `AdditionalLimit::reservoir_remaining`, which revm's result does not carry.
+ A system call stays the protocol's own work: priced at the minimum SALT bucket, paying no history gas, held to no per-transaction limit and not detained, so it settles exactly as op-revm's does on the same configuration with the same split (`tests/satin/system_call.rs`, `tests/satin/equivalence.rs`).
+ A transaction is not a system call: every transaction's gas is split by the execution cap, the system-address transaction's included.
+ The system calls the engine makes, and their gas limits:
+
+ | System call | Target | Gas limit | Regular | Reservoir |
+ | ------------------------------------------------------------------------------------- | ------------------- | ------------------------------------------------- | ------- | --------------------------------------- |
+ | EIP-2935 block hashes, pre-block | `0x0000F908…2935` | `constants::PRE_BLOCK_CALL_GAS_LIMIT`, 31,566,720 | 30M | 1,566,720: sixteen fresh slots at m = 1 |
+ | EIP-4788 beacon root, pre-block | `0x000F3df6…Beac02` | the same | 30M | the same |
+ | `SequencerRegistry.applyPendingChanges()`, pre-block, when a change is due | `0x6342…0006` | the same | 30M | the same |
+ | alloy-evm's `transact_system_call`, revm's `SystemCallEvm` and `InspectSystemCallEvm` | the caller's | revm's `SYSTEM_CALL_GAS_LIMIT`, 31,566,720 | 30M | 1,566,720: sixteen fresh slots at m = 1 |
+
+ The pre-block calls run as the EIP-4788 system address (`0xff…fe`).
+ Their budget is one constant `MegaETH` owns, whatever the block's gas limit, which a pre-block call does not draw on: 30M of regular gas and a reservoir of sixteen fresh slots at the minimum bucket, which holds the most any pre-block call writes (six fresh slots, an `applyPendingChanges()` that applies both roles) more than twice over; it equals revm's default today and does not move with it.
+ None of the three contracts reads `GAS`, so the reservoir changes no call's result; the legacy engine's `max(block gas limit, 30M)`, widened for the storage gas a crowded SALT bucket multiplied, which a system call no longer pays, is gone.
+ A pre-block call that does not succeed refuses the block before its state is committed.
+ One helper runs all three pre-block calls and holds one rule for them (`block/eips.rs`, `transact_pre_block_call`): a database error the database calls fatal (`DBErrorMarker::is_fatal`) is an internal error (`BlockExecutionError::other`), because a read the database could not serve says nothing about the block and a node must not refuse a valid block because its storage failed; any other failure — a database error that is not fatal (under revm's `State`, an EIP-7928 block access list that does not cover a read), an EVM error other than the database's, or an outcome that is not a success — refuses the block with the call's own validation error (`BlockValidationError::BlockHashContractCall`, `BlockValidationError::BeaconRootContractCall`, `MegaBlockExecutionError::ApplyPendingChangesFailed`).
+ It is the rule alloy-evm's block executor holds a transaction's database error to (`BlockExecutionError::evm`).
+
+- The legacy engine's limit-check protocol describes mechanisms that do not exist here; the contracts below replace it.
+ Its gas leakage pitfalls have no counterpart: detention, the one mechanism that caps a frame's gas, withholds it inside the frame's own tracker, where every reader but a regular charge still counts it, so nothing it withholds is ever moved or released (see Gas detention).
+ Its storage-gas stipend does have a counterpart, the history allowance above, and it is a different thing: it never enters a frame's gas limit, so there is nothing to burn on return.
+
+### Gas detention
+
+`MegaETH`'s parallel executor redoes a transaction whose reads another transaction's writes invalidate, and some data changes with every block or transaction.
+Detention caps how much a transaction may still compute once it read such data (`access/`).
+
+- **What is volatile.**
+ The block environment (`NUMBER`, `TIMESTAMP`, `COINBASE`, `PREVRANDAO`, `GASLIMIT`, `BASEFEE`, `BLOBBASEFEE`, `SLOTNUM`, `BLOCKHASH`); the block beneficiary's account, through every account opcode, the four calls and the EIP-7702 delegate they follow, `SELFDESTRUCT` at either end, a sender or recipient that is the beneficiary, a recipient that delegates to it, an applied EIP-7702 authority that is, and a keyless deployment's signer that is (the call reads the signer's account through the journal, so it marks the read itself, at its compute then); the Oracle's storage, through `SLOAD` in the Oracle's own frame.
+ `BLOBHASH` is not: it reads the transaction's own blob hashes.
+ A call to the EIP-2935 history contract is a block-environment read, through the `NUMBER` its code runs before it loads the slot; the storage the EIP-2935 and EIP-4788 pre-block calls write is state the block starts with, and an `SLOAD` of it is none (`test_the_history_contract_reads_the_block_number_and_the_beacon_roots_contract_reads_state`).
+ A system-originated transaction and a system call are not detained, whatever they read, the block environment included: the same rule exempts them from every per-transaction limit.
+ Neither is a transaction under `no_limits()`, which the execution-spec gate's runner installs.
+- **Where a read is marked.**
+ Where the Host loads the value (`evm/host.rs`), and committed by the opcode's wrapper once the opcode completed (`evm/instructions.rs`), as a write record is; a load that fails, and a read whose opcode then fails, mark nothing.
+ The Host refuses and marks a load only while a wrapper runs its opcode (`Detention::begin_read`): `CREATE`'s and `CREATE2`'s loads of their creator and created address, which revm makes through the Host, and an inspector's loads are no reads, neither refused nor marked, as a value call's check of its caller's balance is none.
+- **The cap.**
+ Compute is the regular gas the transaction spends on what it runs, read off `Gas`: a frame's limit less what it has left — its withheld part included, so withheld gas is never spent — less the state and history gas that spilled onto its regular gas; what a halting frame burns is not compute either.
+ The transaction's compute is the running frame's regular gas spent plus every suspended caller's, each less the gas it forwarded its child, plus the stipends of the value calls that returned, less what halts burned: every regular charge an instruction makes, whoever funds it, the burns taken out.
+ What a callee runs on a value call's stipend is compute: the stipend is not forwarded gas, so a caller's contribution while its child runs takes off its forward alone, and once a value call returned its stipend is counted apart, since what the callee left of it came back to the caller's gas on top of the forward; so compute is the regular ledger plus the stipends, less what halts burned, and the gas run after a read is at most the cap.
+ A precompile that runs out of gas counts nothing of its forward: its answer halts and burns it, a value call's stipend included.
+ A read sets a limit — the transaction's compute at the read plus its cap, `EvmTxRuntimeLimits::block_env_access_compute_gas_limit` or `oracle_access_compute_gas_limit`, 20,000,000 each by default (`BLOCK_ENV_ACCESS_COMPUTE_GAS`, `ORACLE_ACCESS_COMPUTE_GAS`) — and the limit only goes down, so the most restrictive read binds.
+ The frames' figures are kept for every transaction detention holds, from its first frame on, as each frame starts, suspends, resumes and ends, so a read at any depth finds the compute of the frames it runs under already summed.
+ `no_limits()` leaves both caps unlimited, and a transaction whose caps are both unlimited is not detained: that is how the neutral configuration's runner turns detention off.
+ It turns detention off together with every other per-transaction limit, so it is for equivalence mode and tests, not for executing the chain; `EvmTxRuntimeLimits::default()` and `ProtocolLimits::for_spec` detain, with caps below `MAX_TX_COMPUTE_GAS`, so a node running the chain never turns detention off.
+- **The enforcement point: the withheld part.**
+ The revm fork keeps a frame's regular gas in two parts (`GasTracker`): a spendable part, the only one a regular charge draws, and a withheld part.
+ Every other reader sees their sum — `GAS`, the 98/100 forward and the clamp on an explicit call gas, the `SSTORE` sentry, the skip-cold checks, the gas a child returns, the reimbursement — and a forward or a state or history spill draws the withheld part first.
+ The forward is Rex6's subtraction, `remaining − remaining × 2 / 100`, in place of EIP-150's 63/64: the fork's `GasParams::call_stipend_reduction` with the quotient 50 (the schedule's `GasId::call_stipend_reduction`) is that subtraction exactly, as `remaining − remaining / 50`; a value call's 2,300 stipend joins the forward after the cap, and a keyless deployment's creation keeps its own forward, `min(gasLimitOverride, remaining)`.
+ The neutral configuration (`MegaContext::with_neutral_cfg`) keeps EIP-150's 63/64, and gives a child the whole reservoir: equivalence mode is Ethereum's forward, not Satin's.
+ `no_limits()` is a separate switch.
+ It turns detention and every other per-transaction limit off, and it does not change the forward.
+ Detention holds a frame's spendable part at what the limit leaves the transaction (`Gas::limit_spendable`): at the read, once its wrapper committed it; at the frame's start, once revm built it (`frame_init`), and every resume (`frame_return_result`); and after `SSTORE`, in the completed-write hook, whose restore of a slot to its original value refills regular gas.
+ So a detained transaction runs exactly as it would without the read until a regular charge needs the withheld part: that charge fails as it would with nothing withheld, and the fork records a `WithheldCrossing` holding the regular gas the frame had before it, both parts together.
+ Nothing withheld is ever released: a frame's withheld part goes back to its caller with the rest of its gas, and `return_create`'s deposit and hash charges, the creating frame's own compute, draw the spendable part like any other regular charge.
+- **The classification.**
+ A frame whose result carries a crossing record crossed the cap (`Detention::on_frame_end`).
+ It is read in the fork's run-result hook (`frame_run_result`, `end_frame`), which revm's plain and inspected loops call once a frame's run returns, after revm processed the frame's last action — `return_create` included — and before anything else sees the result: the inspector's `call_end`, `create_end` and `frame_end`, then `frame_return_result` and the caller, or, for the transaction's own frame, `last_frame_result`, which overwrites the frame's gas with the transaction's; only an out-of-gas is read, since a crossing only ever ends a frame on one.
+ So an inspector and a tracer see the frame end with the stop, as the receipt bills it, and a rewrite of the stop is taken as given like any other; a frame that ends before it runs, which `frame_init` returns, is classified where it ends (`end_before_it_runs`).
+ The frame becomes the stop's revert, `MegaLimitExceeded(2, limit)`, with its gas put back to the record's `remaining`: the charge that crossed is not made, the spendable and withheld parts go back to its caller, and the transaction's compute at the crossing is less than one charge short of the limit.
+ The caller resumes held to what the limit leaves, less than the charge that crossed, so a regular charge of its own past that crosses again and stops it in turn; one that ends within it ends the transaction within the limit.
+ The settlement is the same whether the halt zeroed the frame's gas (`OutOfGas`) or not (`MemoryOOG`, `return_create`'s own out-of-gas on a deposit charge).
+ The stop reports the transaction's compute at the crossing as what was used (`LimitCheck::ExceedsLimit`), the figure the regular ledger bills with the stipends of the transaction's value calls on top, computed the same way at every crossing site; the size of the charge that crossed is not kept, so it is at most the limit — but where an inspector's answer, taken as given, spent past what the limit left its frame, whose spending is its caller's compute.
+ Every other out-of-gas halts and burns as it would without the read: an operand above `usize`, a failed state or history charge, a regular charge beyond the frame's whole gas.
+- **Answers.**
+ revm runs a precompile inside the frame's start, against the frame's gas limit, so a precompile forwarded more than the allowance its frame would start with is decided before it runs (`hold_precompile` in `MegaEvm::frame_init`).
+ One the engine prices (`PricedPrecompiles::price`, `evm/precompiles.rs`) is decided from its price, read with `Precompile::required_gas` off the Satin table's own entry: priced within the allowance, it runs on its whole forward, as without the read; priced past the allowance and within the forward, it is answered without running, out of gas and marked `WithheldCrossing::with_remaining(forward)` (`Detention::cross_at_price`), and stopped by the same classification; priced past its whole forward, it runs on the forward and runs out of gas, a failed call its caller survives, as without the read.
+ A call revm refuses on its caller's account runs no precompile and is answered as without the read: the answer given without running is not given to a value call whose caller cannot fund the value, which a comparison of the caller's balance with the value decides, as revm's transfer does.
+ None of this precedes the call's own regular charges, made at the opcode as any opcode's — its static gas, the value transfer, a cold access — and one that crosses stops the calling frame before the price is read, whether or not the caller can fund the value (`tests/satin/detained_transfers.rs`).
+ One residual is a choice: the price does not tell whether an input passes the checks a precompile makes after its gas check, so an input priced between the allowance and the forward that would fail such a check is the stop, where without the read the check fails the call, which its caller survives.
+ The Satin table prices an address only while the dispatched entry is still its own: not an address a node replaced through `MegaEvm::with_dyn_precompiles` (recorded, whatever id its precompile carries), not one whose dispatched entry carries another id, and nothing once the neutral configuration installed the fixture fork's set; a node's own precompiles carry no price either.
+ Every entry of the Satin table carries one, op-revm's size-limited wrappers of the BN254 pairing and the BLS12-381 MSMs and pairing included: the op-revm fork prices an input within a wrapper's size limit as the run it wraps does, and one past it, which the wrapper refuses before any gas check, at nothing.
+ alloy-evm's `PrecompilesMap` erases what it holds once a node changes it, so a change made around the engine, through the mutable reference to the map that revm's `EvmTr::all_mut` and alloy-evm's `Evm::components_mut` hand out, is not seen: an entry replaced through the map's mutable accessors under the replaced entry's id, and a whole set put in the map's place, whose entries are then priced from the Satin table wherever they carry its ids.
+ Neither accessor is a sign of a change — revm reaches the context through `all_mut` on every frame, and alloy-evm's tracer calls `components_mut` — so a node changes the set through `with_dyn_precompiles` or the factory's builder.
+ A precompile the engine cannot price is run on the allowance and sees it as its gas limit; its answer gets the rest of the forward back (`Detention::restore_forward`), and one that runs out of the allowance is marked as a crossing with its forward and stopped, whether its price is within the forward or not.
+ An interceptor builds its answer on the whole forward, the caller's withheld part included: an answer that spent more regular gas than the allowance the frame would have run on is answered out of gas, marked with `set_withheld_crossing` — its spending the charge that crossed, so its frame gets its whole gas back, less a spill the revert credits — and stopped by the same classification (`settle_answer` in `MegaEvm::frame_init`); the one answer of the engine's own that spends regular gas is that of a `keylessDeploy` call carrying value, and a crossing answer is settled on the limit the caller forwarded.
+ An inspector's answer never reaches the engine's frame start, and is taken as given: no limit holds it.
+ An answer that halts otherwise burns its whole gas limit.
+- **A keyless deployment's call.**
+ The call is the transaction's own frame and runs no code, and detention holds it as any frame: its gas is held to what the limit leaves it once revm built it, before it charges anything, so its own work — the overhead, then the `CREATE` opcode's regular gas — draws the spendable part, and a charge past the limit is a crossing its frame end stops, whether a rule would then have refused the call or its creation would have run.
+ The forward to the creation is not the call's work and draws the withheld part first, as a `CREATE` opcode's does.
+ A call that starts its creation suspends on it as a frame suspends on its child, so the creation's first run adds the call's charges to the transaction's compute, as a caller's work before a `CREATE` is, and the creation runs under what the limit leaves it like any frame; its crossing stops the creation, and the call answers that stop as `ExecutionReverted` on its resume.
+ On its resume the call is held again, as every frame's resume is; it charges nothing more.
+ A call carrying value is an answer, held by the rule above.
+- **What a halt burns.**
+ An out-of-gas zeroes a frame's gas before the frame returns, so the revm fork records what the frame had first: before every deduction that fails, an opcode's static gas, which the step loop charges before the opcode runs, included, and before a halt on a cold access the frame cannot pay (`Gas::failed_charge_remaining`); `Detention::on_frame_end` reads the record, and a halt that zeroes nothing leaves the frame's gas readable in its result.
+ So what every halting frame burns is exact, and none of it is compute.
+ A frame-starting opcode whose caller cannot pay the start's records starts no frame: the frame-start hook hands the forward back before the opcode fails, and records what the frame has then, since the failed charge recorded the gas left after the forward was taken.
+ An inspector's refused charge leaves its record as an opcode's does, as revm leaves it: a later halt that records nothing of its own is read off it.
+- **Refused reads.**
+ `MegaAccessControl` switches volatile-data access off for the frame that calls `disableVolatileDataAccess()` and every frame below it, once the answer is settled and only when gas detention did not turn it into the stop (`Detention::disable_access_on_answer`), until that frame calls `enableVolatileDataAccess()` or returns; a frame below cannot switch back on what a frame above switched off (`DisabledByParent()`), and `isVolatileDataAccessDisabled()` answers for the caller.
+ The caller is the frame one level above the one the call would start (frame depth = the frame-init depth less one, where the legacy engine used the caller's journal depth, the same frame); a transaction that calls the contract directly has no frame above it, so disabling changes nothing, enabling succeeds and the query answers `false`.
+ The state is `Detention`'s, and `MegaContext::with_volatile_access_disabled_from` is the test helper that sets it without a call.
+ The Host then refuses the load and the wrapper reverts the frame with `VolatileDataAccessDisabled(accessType)` on the gas it had after the opcode's static gas, so a refused read pays its static gas and nothing else.
+ `BLOCKHASH` names `BlockHash` (7), though revm's instruction loads the block number first; `SLOTNUM` names access type 12 (`system::SLOT_NUM_ACCESS_TYPE`), which the contract's enum does not declare.
+ The error's argument is encoded as a `uint8`, and Solidity handlers must decode it as `uint8`: Solidity's ABI decoder reverts on an enum value out of range, and the Rust `IMegaAccessControl` binding decodes 12 to its `__Invalid` placeholder; `decode_volatile_data_access_disabled` is the Rust side's decoder.
+ The system contracts are not changed for it: their bytecode, and so their code hashes, stay as deployed.
+
+### Contracts of the common execution layer
+
+Every later mechanism plugs into these; a change to one comes back to this layer.
+
+- **Writes are counted once their opcode completed.**
+ The Host's write methods (`sstore`, `log`, `selfdestruct`) only write, whoever calls them.
+ revm's `SSTORE`, `LOG0`..`LOG4` and `SELFDESTRUCT` call the completed-write hook (`MegaContext::write_completed`) once the write is in the journal and every charge the opcode makes has been made, so a write the opcode's own failure takes back (an out-of-gas after the write) is never counted, and no limit stops a frame for a write that never happened.
+ A tool's write through the Host, an inspector's log among them, reaches no hook and is not counted.
+- **The completed-write hook.**
+ It counts the record on the running frame's pools (`AdditionalLimit::draw`) and holds it to the limits first — in each counted dimension the frame's budget, then the transaction's limit; a crossing is the stop, a revert of the frame — then charges the frame the history the record costs, which is the record's own data size, so the charge and the count are the same number: a log draws on the frame's history allowance first, a charge the frame cannot pay is an out-of-gas, and a record taken back refills its history.
+ A `SELFDESTRUCT` that moved value also counts the transfer log revm journaled for the move, in the same check as its records, and is charged nothing for it.
+ After an `SSTORE` it holds the frame to the compute limit again (`Detention::hold`, the one formula over the frame's `GasTracker`): a restore refills the state gas, revm before the hook, and the history gas, the hook, that spilled onto regular gas.
+- **The frame-start hook.**
+ revm's `CALL`, `CALLCODE`, `DELEGATECALL`, `STATICCALL`, `CREATE` and `CREATE2` call it (`MegaContext::frame_starting`) after every charge they make and after the forward is taken from the caller, before they build the frame's input: it charges the caller the history of the records the start makes, out of what the caller kept, and declares the part the frame's own records cost on the start (`FrameStart::charge`), which revm carries on the frame's input and outcome and refunds to the caller when the frame fails; the history of a creator's nonce record is charged there and not declared, the record outliving the creation.
+ The hook only prices, and counts nothing: a start's records are counted once revm decided it, and a creator's nonce record on the creator once the creation returned with the nonce bumped (`hold_creator`), so no count precedes revm's decision and nothing is given back.
+ After the hook revm takes the frame's share of the caller's reservoir and of each pool out of the caller (`GasTracker::forward_to_child`) and puts it on the frame's input, so a built frame and an answered start both inherit a share of the reservoir the charge left: `remaining − remaining × 2 / 100` (the schedule's `GasId::reservoir_kept_percent` = 2), whatever regular gas the caller asks to forward, the caller keeping the rest while the child runs, and the child's return adds what it left back to what the caller kept, unwinding the caller's outstanding spill first (`absorb_returned_reservoir`).
+ A keyless deployment's creation takes the same share of what the call has left after the call's start charges (`keyless::start`, through `forward_to_child`).
+ The transaction's own frame and a system call's outermost frame take the whole reservoir (the fork's `forward_all_to_child`), and the neutral configuration, on the fixture fork's schedule, gives every child the whole.
+ A caller that cannot pay, or a price that does not fit, gets the forward back and the halt's record re-written, and the opcode fails out of gas without starting a frame.
+ The records the hook prices are one rule over caller, target and value (`Accounts::start_records`), asked at the opcode, a creation's at the address it takes (`FrameStart::target`); the records counted on the started frame's pool are those revm's start made, read off the journal once revm decided it, and a price that differs from them is settled by the start's credit.
+ A start an inspector rewrites after its opcode is not charged again: what the opcode charged stands, and its declared part comes back only as it does for any start whose frame keeps nothing — a frame that fails, or a start revm refuses before it bumps a nonce or moves a value; its records are those revm then made.
+- **The instruction table.**
+ The opcodes that can read volatile data run in detention's read wrapper (see Gas detention).
+ Every other opcode runs revm's instruction unwrapped, and the static gas table is revm's Amsterdam one.
+- **Write records.**
+ One 40-byte record per account or storage write, which follows the net change: a slot's record exists while its value differs from its original in the transaction (made by its first change, taken back on a write-back), an account's while its nonce, balance or code differs from what the transaction loaded, revm's original info (`Accounts::is_changed`): a start's records are read off what revm did — a value transfer's two sides and a creation's created account, as they stood before revm decided the start and as they stand once it did, a creation's creator once the creation returned (an address the transaction funded, or a `SELFDESTRUCT` paid, before the creation lands on it is changed already, and the creation adds no record for it) — and a `SELFDESTRUCT`'s after it, its beneficiary and the account it clears rebuilt as they were from the balance it moved (`CompletedWrite::SelfDestruct::balance`); the applied EIP-7702 authorities and the transaction's own recipient or created account are counted where they are made.
+ So a transfer to an account already changed adds nothing, one that returns an account takes its record back (its history credited to the caller once the frame's start is kept), a value `CALLCODE` or a call to the calling account itself records nothing, and a start whose value the caller cannot fund is charged nothing.
+ The sender's own account is part of the transaction body: validation changes it before execution, so no write to it — a frame running as the sender (through an EIP-7702 delegation), value sent back to it — records it again; a fee account is unchanged until execution writes it, which records it.
+ Records live on the pool of the frame that made them: a success hands them to the caller, a failure takes them back and puts back what the frame took back; a creator's nonce record is the creating frame's, counted on its pool once the creation returned with the nonce bumped, the creation's share having been taken at the opcode before it, so it survives the creation's failure and is held to the creator's budget, not the creation's.
+ It is held to the creator's budget and then to the transaction's limit as it is counted, before the creator runs on, which reverts alone if it crossed (`hold_creator`).
+ The KV count a node reports is the write-record count, which the KV-update limit holds.
+- **The byte pool decides.**
+ A frame's data-size budget is the byte pool on its gas tracker, which the revm fork forwards and settles as it does the reservoir: what the transaction's own execution keeps is drawn there where it is made — a frame start's records and transfer log on the started frame, a completed write and a deposit's code from the Host's hooks — and a frame that fails gives its draws back with its state and history gas.
+ The transaction's limit is held beside the pools, on what the transaction keeps (`AdditionalLimit::usage`): the body, the hints and the authorities' records, which are no frame's, and the frames' draws, counted with them and restored to what they were at a start when that start's frame keeps nothing (`AdditionalLimit::close_start`, one entry per start revm decided, keyed by its depth).
+ The entry also carries what a pool cannot: the write-record count and the transfer logs the transaction reports apart from its bytes, the take-back credit a kept start gives its caller, and a creation's creator as it stood before revm decided it.
+ Nothing a tool or a precompile writes is drawn or counted: only the hooks draw, and only where the transaction's own execution writes; a tool's checkpoint the tool reverts takes the writes back but not the draws.
+ The one exception is a node's own precompile that writes in a success answer, which revm runs inside the start: a start is read off the journal once revm decided it, so what the precompile changes of the start's own accounts — the nonce, balance or code an account's record follows, and one account of state growth for each that was empty and it leaves not empty — and a transfer log it journals are read with the start's, a start counting one transfer log, its value's or the precompile's; its storage writes and its writes to any other account are not (`tests/satin/tool_writes.rs`); the Satin set writes nothing.
+ Every verdict is the layer's: a completed write's, a deposit's and a hint's check, a frame's budget, the verdict on a start once revm decided it, on what it made, the check of a caller at every child's return; a start's history comes back to its caller with the fork's start charge when the frame fails, and the price of the records a kept start took back on the frame's result before revm merges it.
+- **A start's charge rides on revm's carriers.**
+ The frame-start hook declares what a start's own records cost on the start (`FrameStart::charge`), revm carries it on the frame's input and outcome and refunds it when the frame fails, for a frame it built and an answer it gave alike; the transaction's own frame carries its record's charge on its input from `first_frame_input`, refunded by the shared first-frame settlement. An answer the engine builds itself carries its input's share and charge (`synthetic_frame_result`); an inspector's answer carries what the inspector built it with.
+ The history allowance a value call gives its child is the fork's tracker field, set from the schedule's `call_history_allowance`; only a log draws on it.
+- **The stop.**
+ A limit stops the frame that crosses it with a revert, never a halt, whether the limit is the transaction's or the frame's own budget: the frame reverts with `MegaLimitExceeded(uint8 kind, uint64 limit)` (`AdditionalLimit::crossed`, for the data size and gas detention's compute stop alike, answering the exemption), what it counted goes with its frame, and its caller resumes as after any revert.
+ There is no latch: a caller that resumes is within every limit — but where a failure below it put back a record a frame above made while a hint the failed frame sent stays, which stops the caller as it resumes (below) — is held to what the transaction has left, and is stopped in turn by a write or a charge of its own that crosses one, so the transaction never keeps more than its data-size limit and never computes past detention's limit; a caller that catches the stop and ends lets the transaction succeed.
+ The frame budget is what keeps a caller's own work within reach of a callee: a child inherits 98/100 of the caller's reservoir and history gas draws it first, so gas does not bound what a child appends, and without a budget a callee could take the transaction to its limit and leave the caller that caught its stop nothing to carry on with; the reservoir the caller keeps, `remaining × 2 / 100`, is what is left of its gas for state and history whatever the child spends.
+ A child gets 98/100 of the remaining reservoir by the subtraction `remaining − remaining × 2 / 100`, and 98/100 of the parent's remaining data size by `parent_remaining × 98 / 100`, rounded down.
+ The neutral configuration keeps the whole reservoir and EIP-150's 63/64 forward.
+ A frame returns a stop before running another instruction in two cases: when its own start crossed a limit once revm built it, which ends the frame in `frame_init` before it runs, returned as an answer is (`end_before_it_runs`); and on a resume, when the nonce record of a creation it made, counted on it as the creation returns, puts it over a limit (`hold_creator`), or a child's failure leaves the transaction over one — the failure restores what the frames kept at the child's start, and an Oracle hint the child sent into room a take-back freed stays (`AdditionalLimit::hold_caller`) — which `frame_return_result` sets on the frame's interpreter for its run to return.
+ A stop of the transaction's own frame is the transaction's result, which settles like an EIP-8037 revert, its unspent regular gas and the reservoir back to the sender; the history charged before execution for that frame's write record comes back with its start charge at the settlement, whenever the frame did not keep the record.
+ Nothing is rescued for the sender on a stop, because nothing was taken from it: the stop settles on the gas the frames hold, and detention withholds inside a frame's own tracker.
+ A stop of the transaction's own frame reverts what the frames did, the first frame's value and write record included, and nothing pre-execution applied: an admitted EIP-7702 authority keeps its nonce, its delegation, its state gas, its record and that record's history, and a deposit keeps its mint and the caller account it created, as through any failed first frame (`tests/satin/state_growth.rs`).
+ A limit is enforced on the writes it guards before anything runs on them: a frame whose start crosses it returns the stop before its first instruction, or its success answer gives way to the stop, and what the start moved goes back with it (a creation keeps its creator's nonce bump, which revm makes before the frame's checkpoint, so a stopped creation transaction cannot be replayed); an answer that failed kept nothing and is held to nothing.
+ Nothing counted before the first frame crosses the data-size limit: validation (`MegaHandler::validate_initial_tx_gas`, before any gas check) refuses a transaction whose body, with a 40-byte record for each entry of its authorization list, exceeds it (`AdditionalLimit::admits_tx_body`, `TX_BODY_OVER_DATA_SIZE_LIMIT`, an `InvalidTransaction::Str`), the system-originated exempt; a deposit refused so is a failed deposit, and a pool refuses it through `validate_transaction_stateless` alike.
+ The body is a pure count, and `AdditionalLimit::count_authorities` asserts in debug builds that the records cannot cross; at the spec's numbers the gas checks already bound a body with its records to 6,732,889 bytes (`tests/satin/pool_validation.rs`).
+ A frame revm answers with a success and the engine then rewrites to the stop — gas detention's crossing — has its journal taken back to where its start began, at any depth, as revm takes back a frame that fails (`take_back_a_stopped_answer`): its caller resumes and keeps its own writes, and no caller's revert follows to take the answer's back.
+ A record is checked before its history is charged, so a record the limit rejects is not charged and the stop is what its frame reports; at a frame start the caller pays at its opcode, before revm decides the start and its records are held to the limits, so there an out-of-gas comes first, even for a start revm then refuses.
+ A real out-of-gas, a precompile out-of-gas and an invalid opcode still halt and burn; an out-of-gas before the first frame takes back what pre-execution counted and keeps the body.
+ The layer's state belongs to one transaction: the handler resets it first thing, in `validate_env`, once it knows whether the transaction is the protocol's own, and every system-call entry point of `MegaEvm` resets it before it runs the handler's system-call path.
+ The outcome's `limit_exceeded`, not the output, tells a stop from a contract reverting with the same bytes: it names the crossing that produced the result of the transaction's own frame — a transaction-level limit or that frame's own budget in data size, KV updates or state growth — noted where the stop became a frame's result (`AdditionalLimit::note_frame_stop`) and kept only while that frame's result is still the stop's revert; a stop a caller caught, and re-raised or not, is none.
+ `LimitStop::from_result` (and `MegaTransactionOutcome::limit_stop`) reads a stop off the two together, for an RPC's error; `decode_mega_limit_exceeded` reads the bytes alone, which make no stop by themselves.
+ `tests/satin/stops.rs` pins the protocol as a matrix: every limit crossed by the transaction's own frame and three calls down, whose callers catch the stop and succeed, below and above the execution cap, with and without an inspector that records every frame's end, and a column of stopped creations an inspector revives, which settle as the successes the inspector made of them.
+- **A per-frame gas cap stays inside the frame's tracker.**
+ Detention caps a frame's regular gas with the fork's withheld part (`Gas::limit_spendable`), which every reader of the frame's gas but a regular charge counts, so it moves no gas between pools and has nothing to release: a child's withheld part goes back to its caller with the rest of its gas, and a stop settles on the crossing record where the frame's run returns (`frame_run_result`).
+ A later mechanism that caps a frame's gas uses the same part; it limits the frame at its start and again after every credit — a child's return, `SSTORE`'s refill — and never releases a creating frame's withheld part before `return_create`, whose charges are the frame's own regular charges.
+- **Synthetic frame results carry the caller's pools.**
+ A result built without running a frame is a `synthetic_frame_result`: gas untouched with the inherited reservoir and byte share (`untouched_call_gas`, `untouched_create_gas`), never `Gas::new(limit)`, and the calling opcode's upfront state-gas flags and start charge, so revm's own frame return settles it exactly like a result of its own.
+- **Inspectors in block execution.**
+ Block execution admits any inspector: which inspectors may run on block production is a node's decision, not the engine's.
+ A block builds from an EVM the node made with `MegaEvmFactory::create_evm_with_inspector` (or `MegaEvm::with_inspector`) and `MegaBlockExecutorFactory::create_executor` (or `MegaBlockExecutor::new`).
+ An inspector sees the transactions, user and system alike, and nothing else: the pre-block calls run on the handler's plain system-call path, as alloy-evm's `transact_system_call` runs one, and the end of the block runs no code; the `evm` module doc holds what an inspector sees and may rewrite.
+ `test_utils::ReadOnlyObserver` wraps an inspector that is meant to write nothing back and proves it in debug builds, for tests.
+ No rewrite is refused, and none is corrected: the engine takes a rewritten result as given (below).
+ The test utilities' inspectors are not declared.
+- **A rewritten result is taken as given, as revm takes it.**
+ revm commits or reverts a frame's journal checkpoint before the inspector sees the frame's result, and the caller settles the result the inspector hands back, its classification, output and gas, reservoir and byte pool included; the engine adds nothing to that settlement.
+ A failed frame revived into a success — Foundry's `expectRevert` on a call that wrote and reverted — keeps its journal reverted and settles as a success: its state gas, history, refund and the records it counted merge into its caller, and the upfront charge its caller's opcode made stays.
+ A success rewritten into a failure keeps its journal, the inspector's own writes in that callback included, and settles as a failure: its charges roll back, its counts are restored with its start's entry and its start charge is refunded.
+ A frame an inspector answers in place of running never started: what its caller's opcode was charged for it — the upfront state gas and the history of its start's records — stays charged unless the answer carries the upfront-charge flags and the start charge back; a creation's creator record is not counted, revm having bumped no nonce, and its history stays charged; and the answer settles on the gas it is built on.
+ So a tool's state and its ledgers can part under a rewrite, as they do under revm; keeping them consistent is the tool's business, and block execution runs no rewriting inspector the node did not choose.
+ The write records and transfer logs the transaction reports follow the result its caller settles, as the byte pool does (`AdditionalLimit::close_start`).
+- **An inspector's writes to gas.**
+ Gas an inspector writes in the `step_end` of a frame's last instruction reaches nobody: the instruction copied the frame's gas into its result; the result's gas, rewritten in `call_end`, is what the caller merges, reservoir included.
+ An answer settles on the `Gas` it is built on: `Gas::new(limit)`, which Foundry answers every cheatcode on, carries no reservoir and unlimited pools, so above the execution cap — Foundry's default gas limit of 2^30 is above it — the caller is left only the 2 per cent of its reservoir it kept when it handed the call its share, as the fork's add-settlement has it.
+ A charge the frame cannot pay is refused and takes nothing, and the frame runs on, with the record of the refused charge left on its gas, as revm leaves it: a withheld-part crossing stops nothing in a frame that ends without an out-of-gas, and a later halt that records nothing of its own is read off the failed-charge record.
+ An inspector that overwrites the interpreter's gas (Foundry's `pauseGasMetering` restores a snapshot before every instruction) overwrites detention's split with it, and the frame runs on the snapshot's split until detention next holds it: at a read, a start or resume, or after an `SSTORE`.
+- **The interceptor dispatch.**
+ Its order is the scheme guard, the address, the selector, then the method's value policy, each step cheaper than the next: `CALLCODE` and `DELEGATECALL` never reach an interceptor, because they run the callee's code in the caller's context; the address test is one comparison against the shared `0x6342…` prefix and runs on every call a transaction makes; the selector is peeked without materialising the calldata behind it, and is admitted on its four bytes alone, trailing bytes and all.
+ A selector a contract does not intercept is not intercepted: the call falls through, which is to say the deployed bytecode runs, and what it answers is that contract's own.
+ The two control contracts have a fallback that reverts with `NotIntercepted()`; `KeylessDeploy` has none, so a selector it does not declare reverts with empty data while a `keylessDeploy` call the keyless dispatch did not take — one a contract makes — reaches the method body's `NotIntercepted()`; the Oracle's other selectors are methods it runs, and one it does not declare reverts with empty data.
+ A method that takes no value answers a value-bearing call with `NonZeroTransfer()`, or with the error its own ABI names, after the selector matched — so a value-bearing call to an unknown selector still falls through.
+ An answer is a synthetic frame result and carries the reservoir; an interceptor that lets the frame run charges nothing.
+- **One hook prices every state charge.**
+ `Host::state_gas_price(id, site)` is the single place an EIP-8037 state gas charge is priced.
+ A charge is given back two ways, and neither reads a second table: `SSTORE`'s own restore, a caller's upfront charge for a call or creation that did not add the leaf, the transaction-level refund and the settlement of a synthetic frame result re-price the same `(id, site)` pair through the hook; a frame that fails rolls its own charges back by the amounts it recorded while running, without asking for a price at all.
+ Both cancel the charge exactly whatever the price was — the re-priced sites because a bucket's multiplier is read once per transaction, so the two cannot disagree even if the environment's answer would, and the rolled-back amounts because nothing but the hook priced them.
+ The one exception is an inspector's: revm reads the account a call's upfront charge is given back for off the frame's inputs, so an inspector that rewrites a call's target has the charge given back at the new target's price, as under revm (`tests/satin/inspector_settlement.rs`).
+ A charge on an account created in the transaction and destroyed since prices at nothing: its destruction gave back what the transaction had charged for it, at the prices charged and outside that rule (`MegaContext::priced_state_gas`), so a re-pricing after the mark — the restore of a slot it gave back — gives back nothing a second time.
+ A mechanism that adds a state charge adds a `StateGasCharge` at the site the state lands on; it must not price the charge itself.
+- **Three ledgers, and the bytes beside the third.**
+ `MegaGasUsage` splits a transaction's raw spend into regular (compute), state and history gas, all paid from the EIP-8037 pools, reservoir first; state or history gas that spilled onto regular gas stays on its own ledger.
+ The regular ledger is `total − state − history`, read off the result revm's `Gas` settled into; nothing counts compute beside it, so gas an inspector edits moves it with the receipt.
+ The figure a block counts is `max(regular, floor)`, history taken out before the floor applies: the fork's `block_regular_gas_used` keeps history in, and subtracting it afterwards can land below the floor.
+ The three add up to the raw spend, which is why what a history allowance paid for is on none of them: no pool of the transaction's gas paid it.
+ `history_bytes` counts it all the same — the body, one 40-byte record per kept write, the kept logs but for the transfer logs, and the deposited code — so the bytes at the cost per history byte exceed the history gas by exactly what allowances paid; an exempt transaction reports neither.
+ It is the history the schedule prices, not the chain's physical growth: an exempt transaction's bytes are not in it, and a body counts its five fixed write records even when fewer fee accounts are written.
+ For a transaction that pays history it is the data size the transaction kept less its Oracle hints' payloads and its transfer logs: both columns read one count at every site, deployed code included, which the data-size limit makes before the creation commits and only for code revm deposits.
+ `gas_used` is the receipt's figure; `BlockGasCounters` sums the three ledgers and the history bytes per block.
+ `reservoir_remaining` is what the EIP-8037 reservoir held where revm built the result's gas, before the EIP-7623 floor absorbs it; revm's `ResultGas` does not carry it, so the handler reads it and the layer reports it (`AdditionalLimit::reservoir_remaining`), for a system call too.
-1. **Every non-compute mutation site must latch.**
- Any code that records data-size/KV/state-growth usage during execution (`on_sstore`, `on_log`, `record_oracle_hint_bytes`, the frame-lifecycle hooks) must run `check_limit()` itself, latching any exceed into `has_exceeded_limit`.
- The latch is surfaced by the leading short-circuit of the next `record_compute_gas` call, so the halt lands on the same opcode as the pre-protocol fan-out did.
-2. **Pre-inner recorders must NOT latch.**
- A site that records usage _before_ its inner instruction executes (currently SELFDESTRUCT's two beneficiary recorders: empty-beneficiary creation and the REX6+ existing-beneficiary credit) must record without latching: the inner instruction can still fail, the frame then discards the usage, and an early latch would stick and rewrite the frame's real result.
- Such opcodes use a trailing all-dimension check (`record_compute_gas_all_dims`) that runs only after the inner instruction succeeds.
-3. **Compute gas is always recorded.**
- `record_compute_gas` must record before surfacing any latched exceed — the recorded total feeds the transaction outcome and block-level compute accounting even for transactions halted on another dimension.
+## Test Organization (`crates/mega-evm/tests/`)
-The protocol governs mutation sites that run during execution; the REX6+ post-execution fee-reward accounting is deliberately outside it.
-That accounting merges usage into the transaction's reported totals and the block-level cumulative counters after the execution result is final, without latching, and never retroactively fails the transaction.
+- `satin/` — tests of the Satin engine (integration tests; add new ones here or in a new directory with a `main.rs`).
+- `block/` — tests of block execution: the Karst block rules, the block-level limits, the counters and the factory; under `block/witness/`, the witness-replay harness: a block executed on a recorder of every read, then again on a strict database and environments that serve exactly a witness — the record of every read, and the witness a node builds from the states the block committed (the pre-block steps' and the included transactions') and the exports — each replay held to the recording, one case per mechanism that reads and per read that gas or a limit skips.
+- `system/` — tests of the system contracts: the interceptor dispatch, what each contract answers, keyless deployment (`system/keyless/`) and the system-address transaction.
+- `fuzz/` — randomized tests: properties the engine must hold on any input, and the neutral differential against op-revm and revm's mainnet EVM (see Randomized tests below).
+- `shared/` — no target: `snapshot.rs` holds `assert_sorted_json_snapshot!`, which every target includes with `#[path = "../shared/snapshot.rs"] mod snapshot;`, and `op_reference.rs` the op-revm reference the baselines compare with, op-revm's handler with Satin's system-call split and the reservoir its result settled with, which the `satin` and `block` targets include the same way.
+ It has no `main.rs`, so Cargo builds nothing there; the snapshot files live in `snapshots/` beside the file that asserts.
+- Unit tests live next to the code in `#[cfg(test)] mod tests`.
-Rule 1 is backed by a `debug_assert!` in `record_compute_gas`: if a non-compute dimension is over its limit but not yet latched, the assert trips at the exact opcode whose mutation site forgot to call `check_limit()`.
-The sub-tracker checks are non-mutating, so the guard compiles out of release builds.
+### Randomized tests (`crates/mega-evm/tests/fuzz/`)
-When adding an opcode or mutation site that touches a non-compute dimension, decide whether it records after or before its inner instruction, follow the matching case above, and add a test asserting the exceed halts at that opcode.
+The hand-written tests fix an input and an expectation; the randomized ones draw the input and state what must hold of any outcome.
+They run on `proptest`, through the target's own runner (`harness.rs`), and every property is one `#[test]`.
-## Test Organization (`crates/mega-evm/tests/`)
+```bash
+cargo test -p mega-evm --test fuzz # the bounded mode, as CI runs it
+cargo test --release -p mega-evm --test fuzz # the same in release, where the debug assertions are gone
+MEGA_FUZZ_LONG=1 cargo test -p mega-evm --test fuzz -- --nocapture # the long mode: 50x the cases, a seed from the clock, printed
+MEGA_FUZZ_SEED=7 MEGA_FUZZ_CASES=5000 cargo test -p mega-evm --test fuzz -- --nocapture a_stop_keeps # one property, a chosen run
+for s in $(seq 1 20); do MEGA_FUZZ_SEED=$s cargo test --release -p mega-evm --test fuzz || break; done # other seeds, before changing a generator
+```
-Tests are organized by spec: `equivalence/`, `mini_rex/` (12 modules), `rex/`, `rex2/`, `rex3/`, `rex4/`, `rex5/`, `rex6/`, and `block_executor/`.
-Each module tests specific features of that spec.
+- **Two modes.**
+ The bounded mode is deterministic: seed 0, a fixed case count per property (128 to 768), under ten seconds in debug.
+ It is part of `cargo test --workspace`, which `build-and-test.yml` runs in debug (`test`), where every debug assertion runs, and in release (`test-release`), where none does.
+ The long mode (`MEGA_FUZZ_LONG=1`) multiplies each property's count by fifty and draws a seed from the clock unless `MEGA_FUZZ_SEED` names one; `fuzz.yml` runs it on `workflow_dispatch`, in debug and in release, since a schedule fires only on the default branch.
+ `MEGA_FUZZ_SEED` names the seed in either mode.
+ `MEGA_FUZZ_CASES` names the case count in either mode, and it is the count: every property runs exactly that many cases, and the long mode's multiplier does not apply to it.
+ Either variable set to the empty string counts as unset, which is how `fuzz.yml` passes an input left empty.
+- **The properties hold for any seed.**
+ Seed 0 is what CI runs, not what the properties are true of: a change to a generator redraws every case, so a property that held on one seed by luck fails on the pull request that touches a weight.
+ Before changing a generator or a property, run the bounded mode on a few dozen seeds and the long mode on a few; a failure there is a bug to fix or a property to correct, never a seed to avoid.
+- **A failure is reproducible.**
+ The runner panics with the property's name, the reason, the seed and case count that reproduce the run, and the case proptest shrank to within its shrink limits (two minutes and 4,096 steps, so not always the minimal one), rendered as the generator types (`Case`, `BlockCase`), from which a regression test is written by hand into `regressions.rs`.
+- **The generators** (`gen/`) build a `Case`: a `World` (four fixed accounts, a beneficiary that may be one of them, a delegation, SALT capacities with multipliers above one and a failing bucket, the Oracle's answers, runtime limits in place of the spec's, the block), a `Tx` of one of six shapes (call, creation, EIP-7702, deposit, system-address, keyless) at five gas tiers, and the `Program`s of the three contracts, lists of self-contained ops biased towards what the engine meters.
+ A call, an account read or a `SELFDESTRUCT` may name the address one of the program's own `CREATE2` ops lands on (`Target::Created`), so a program can fund or pay an account before it creates it.
+ A keyless deployment carries its own world: the signer's funds, nonce and code, what the deploy address holds, how the carried transaction is encoded and what it is signed for, so that each of its rules is reached.
+ The keyless property also pads one init code in eight with zero bytes, which never run, to the initcode size limit, one byte past it or twice it; the other properties draw init code at its own size, since a mebibyte of calldata in their cases would buy nothing they check.
+ The weights keep what refuses a transaction before it runs rare — about one case in five — because most properties have nothing to check of a refusal.
+ `Case::execute` runs it on a fresh EVM; `blocks.rs` runs envelopes through `MegaBlockExecutor`.
+ `Flavor::Neutral` replaces what only `MegaETH` has by its plain counterpart, for the differential, and `Case::without_destruction_in_creation` takes every self-destruction out of init code for the one comparison that settles it otherwise, Ethereum's on Amsterdam.
+- **What the properties state** (`properties.rs`, `keyless.rs`, `blocks.rs`, `differential.rs`): the same outcome twice, under a recording inspector, and on an EVM that already ran another transaction, one that ended in an error included; the gas ledgers, the reservoir exactly; `KV × 40 ≤ data size` after every instruction, and every transaction keeps its body and the hints it forwarded; the write-record count as the net change of the state, computed from the case's pre-state and the outcome's state with the settlement's fee credits taken out; what a stop keeps; a keyless deployment's rules in the spec's order, its answer and its signer's nonce; a block's counters as the sum of what its transactions report, and its budgets; the neutral differential.
+ A panic fails whichever property draws the case.
+ Several print a tally of what they reached (`--nocapture`): how the previous transaction ended, each keyless rule, the cases rewritten for Amsterdam.
+- **To add a property**, write a `#[test]` that calls `harness::check(name, bounded_cases, || case(Flavor::Satin), |case| { ... })` and returns `Err` through `prop_eq!` / `prop_check!` where the outcome breaks the property; keep the bounded case count such that the whole target stays under a minute in debug.
+ A property that does not hold by design is stated as what does hold, with the reason in its doc comment, never weakened silently.
+ An expected value is computed from the case or from what the transactions themselves report, never read back from the thing under test: an assertion that restates a definition, or compares a counter with itself, cannot fail.
+ To add an op or a transaction shape, extend the enum and its strategy in `gen/`, its assembly, and, if op-revm cannot express it, its `neutralized` counterpart.
+- **The byte prices** are a process-wide constant, so a case cannot run at two prices in one test.
+ `prices.rs` checks the schedule builder's monotonicity in-process, and under `satin-price-override` records what every case spent (`MEGA_FUZZ_PRICE_RECORD`) for `scripts/fuzz_price_monotonic.py` to compare two runs at two prices, which `fuzz.yml` does.
+ The properties themselves hold at any byte price and run in the byte-price grid; the regression tests that fall short of a charge pin a minimal case at the spec's prices and return early at others.
+
+## Test Gates
+
+`REVIEW.md` lists the test gates a pull request meets ("Test gates"); three of them are this repository's own execution gates — the op-revm baseline, the execution-spec gate and the witness replay — and the byte-price grid holds the suite at other byte prices.
+
+- **The op-revm baseline** (`tests/satin/equivalence.rs`): an ordinary transaction through `MegaEvm` against op-revm on the same configuration, which Satin differs from by its history ledger alone.
+- **The execution-spec gate** (`crates/mega-state-test`, `.github/workflows/exec-spec-satin.yml`): Ethereum's state-test fixtures through `MegaEvm`, on the fixture releases the fork's own runner (`.github/workflows/exec-spec.yml`) uses.
+ - Equivalence mode is the gate: Satin's machinery — handler, frame lifecycle, Host, instruction table — priced as the fixture's fork prices it, through the neutral configuration (`MegaContext::with_neutral_cfg`, `test_utils::{neutral_cfg, neutralize_evm}`), which exists only behind `test-utils`, and held to no runtime limit (`EvmTxRuntimeLimits::no_limits()`, installed by the runner itself).
+ The neutral configuration keeps EIP-150's 63/64 forward and gives a child the whole reservoir.
+ `no_limits()` is the separate switch that turns the per-transaction limits off.
+ The counts it reports (`LimitUsage`: data size, write records, state growth) are the engine's own, by Satin's rules, and no fixture checks them: the neutral configuration prices what the fixture's fork prices and counts what Satin counts, the destruction table's give-backs included, so a change to a counting rule moves an equivalence-mode transaction's whole-outcome digest in `usage` alone, which is that change's and is no deviation.
+ Every failure must be explained by a deviation in `crates/mega-state-test/src/deviations.rs`, with its rule, its reason and the exact entries it explains, each with the hashes Satin produces, and every listed entry must fail exactly as listed; the executed and skipped counts are pinned in the workflow and equal the fork runner's.
+ - Satin mode is a report: the same fixtures under Satin's own configuration, counted by outcome in the step summary; it never fails the job.
+ - The blockchain tests are a gate too (`state-test btest`, `crates/mega-state-test/src/blockchain/`): the main release's Osaka `blockchain_tests`, imported block by block through `MegaBlockExecutor` on `MegaEvm` in equivalence mode's configuration, held to no limit (`ProtocolLimits::no_limits()`, installed by the runner through the executor's test-and-tool override), as the state-test runner holds a transaction.
+ Every accepted block's gas used, logs bloom, receipts root and state root are held to its header, every block expecting a `TransactionException` must be refused for an exception it names, leaving the chain at the previous block, and the chain must end at the fixture's last block and post-state.
+ The runner seeds the seven predeploys, in the shape Rex6 left them, where a fixture's pre-state lacks them, and sets the activation signal from the schedule; the state root takes out those accounts and OP's three fee vaults a Satin block adds (`SATIN_ACCOUNTS`) only when the pre-state does not hold one and it holds exactly what was put there.
+ A test is skipped only for a class decided from its content: withdrawals, blob transactions, EIP-7685 requests, a header or body `BlockException` a node checks before execution, a transaction an OP block cannot encode, and the state-test gate's own storage-collision files; the executed tests and each class are pinned in the workflow.
+ A block that differs passes only when a deviation the registry already has lists that test and block with exactly the outcome Satin produces (gas used, logs bloom, receipts root, state root); the chain is imported on from Satin's state, every later block held to its header or its own listed outcome, and the summary counts blocks checked against Ethereum apart from blocks matched to a deviation.
+- **The witness replay** (`tests/block/witness/`, `crates/mega-state-test`'s `witness::check_replay`): a block, or a fixture's transaction, executed on a recorder of every read and replayed twice on a strict database and environments that serve exactly a witness and refuse everything else — once on the record of every database read, once on the witness a node builds from the states the block committed — the pre-block steps' and the included transactions' returned states — and the engine's exports (`WitnessRecord::from_channels`); every replay runs only the transactions the recorded block included and must agree with the recording on everything produced, the replay must read nothing its witness does not hold, and the executor's exported buckets and block hashes must be the side-channel reads the block made, a bucket only where the SALT environment answered it with a valid capacity.
+ The channel replay is the check a validator's witness must pass; the database-level replay shows the block has no hidden input.
+ A fixture entry the engine rejects has no returned state to build the channel witness from, and replays on the record alone.
+ The block tests cover each mechanism that reads, in the `test` job; `exec-spec-satin.yml` replays every Osaka and Amsterdam entry of the fixture releases in both modes and fails on any entry that does not replay, counting the entries replayed on both witnesses apart from the rejected ones.
+ The fixture test is always ignored by default: it runs only with `-- --ignored` (or `--include-ignored`) and `MEGA_STATE_TEST_FIXTURES` set to the fixtures, and setting the variable alone runs nothing.
+- **The byte-price grid** (`scripts/price_grid.sh`, `.github/workflows/price-grid.yml`): the `mega-evm` suite with the `satin-price-override` feature at other costs per state and history byte, five points on a pull request and the whole grid nightly.
+ The prices are provisional, so a test holds at any of them — a byte price of nothing, or one gas per byte up to the grid's dearest point: it sizes its gas from the schedule at the prices in effect, and a case whose scenario is state or history gas returns early where that byte costs nothing (`state_is_free`, `history_is_free`).
+ Below one gas per byte the schedule's entries round to nothing one at a time, and no test is held there.
+ Each guard leaves a note (`test_utils::note_price_guard`), and the grid reports per point how many tests were guarded beside how many passed.
+ A test that only skipped a snapshot comparison leaves a note of its own (`test_utils::note_snapshot_skipped`), which the grid counts apart, as snapshot skips: it ran every assertion it makes.
## Version Control
-The main branch is `main`, but it's protected.
-All change should be made via PRs on GitHub.
+`satin` is the integration branch of the new engine; pull requests for Satin target `satin`.
+`main` carries the legacy engine and is not touched from Satin work.
+Both are protected: all changes go through PRs on GitHub.
### Branch naming convention
@@ -274,17 +635,20 @@ The commit message should be short and exclude any information of the agent itse
When a PR creation is requested, the agent should:
-1. Check if the repo is current on a different branch other than `main`.
+1. Check if the repo is current on a different branch other than `satin` or `main`.
If not, create and checkout to a new branch.
Make sure to inform the user about this branch creation.
2. Commit the changes in the worktree before fix linting issues.
3. Run lint check, and fix any lint warnings, and then commit if there are any changes.
4. Format the code and commit if there are any changes.
5. Push to the remote.
-6. Use `gh` CLI tool to create a PR.
+6. Use `gh` CLI tool to create a PR against `satin`.
When generating the PR title and description, consider the overall changes in this branch across commits.
In the PR description, make sure a `Summary` section is put on the top.
The PR will be merged with `Squash and Merge` operation, whose commit description should include the summary.
+7. Label the PR as `.github/pull_request_template.md` lists.
+ Satin is the unstable spec, so a PR that changes Satin's behavior is `spec:unstable`.
+ `spec:new` is only for a PR that introduces a new `MegaSpecId` variant.
### Implementing features or bug fixes
@@ -295,9 +659,41 @@ When the agent is requested to implement a new feature or bug fix, it should con
## Caveats for Agents
+- **Reviewing the Satin pull request: use `.claude/skills/satin-review/`.**
+ It is temporary and removed before the Satin pull request merges.
+- **Satin is the unstable spec; the legacy engine is frozen.**
+ Do not add legacy specs or alias rungs to this crate, and do not port a legacy mechanism the legacy test inventory retired.
+ Spec gates come with the next spec (see Spec System), not before.
+ Behavior of the legacy specs is changed only on the legacy line, never here.
+- **Keep each change in the module that owns it.**
+ The module table says where each mechanism lives; a change that needs another module's interface extends that module rather than re-implementing it in its own.
+- **Export from the crate root by name.**
+ `lib.rs` lists every item of the public surface explicitly, and the few `pub(crate)` items the modules share through the root; there are no glob exports and no short aliases.
+ A new `pub` item is added to that list or made `pub(crate)`: the `unreachable_pub` lint flags one that is neither.
- **Always test logic changes.**
Any logic change or modification to mega-evm should be equipped with tests if there is no specific reason of not adding tests.
The agent should always consider accompanying tests or suggest to add additional tests.
+- **Keep the op-revm baseline honest.**
+ A change that makes Satin differ from op-revm on purpose must update `tests/satin/equivalence.rs` (or add a case) so the difference is pinned, not silently absorbed.
+- **Hold a test at any byte price.**
+ A gas limit is regular room on top of what the scenario adds at the prices in effect (`satin_gas_params()`, `history_gas`), never a number that happened to cover it at the constants; a call or creation that forwards all but 2 per cent of its gas keeps a fiftieth of what it held, so it must hold 50 times the history of the records it pays for (`common::holding_to_keep` inverts the split).
+ A charge a scenario must not be able to pay is derived the same way — a gas limit one short of it — not a number that is short of it only while a byte is dear.
+ A test that pins the spec's own numbers returns early at other prices (`runs_at_measurement_prices`); run `scripts/price_grid.sh --pr` before committing a test change.
+- **Pin only outputs with no computable expectation.**
+ A snapshot or a golden is the owner of an output no test can compute an expectation for, and of nothing else.
+ Those outputs are the tracers' formats (`tests/tracers/`, the call-with-logs and prestate-diff views per scenario with the gas figures redacted, and the opcode view of two), recorded traces, such as the keyless differential's record pinned by one digest per case (`tests/system/keyless/differential.rs`), and the receipt bytes a node hashes, hand-pinned in `tests/block/receipt_goldens.rs`.
+ A figure the schedule and the named constants determine — gas on any ledger, a usage count, a limit, a balance, a slot, a log — is asserted with `assert_eq!` against its derivation, never pinned.
+ A snapshot is never a net over a behaviour test: a test that runs a transaction asserts what it owns and snapshots nothing of its outcome.
+ A digest stands for a record too large to keep in the tree, so a changed digest is reviewed through the record's dump: `MEGA_KEYLESS_RECORD=` writes the keyless record, written at the base and at the head and diffed; it is never accepted on the digest alone.
+ A digest also moves wholesale when the rendering of a type it covers changes, such as a dependency's `Debug` format, and the dump is how that change is read too.
+ Snapshot changes are reviewed one by one like code: with `cargo insta review`, or by diffing each `.snap.new` against its `.snap` and accepting it on its own (`cargo insta accept --snapshot `, or, without cargo-insta, moving it over the `.snap` without its `assertion_line:` header line).
+ They are never blanket-accepted (`cargo insta accept` of every pending snapshot, `--accept`, `--force-update-snapshots`, `INSTA_UPDATE=always`).
+ Snapshot comparisons run at the spec's byte prices only: at other prices the macro skips the comparison and leaves a note of the skip (`test_utils::note_snapshot_skipped`), not a price guard.
+ The receipt goldens are the one pin outside insta, on purpose: the receipts root, the blooms and the encoded receipts are hand-written constants, the stronger pin for consensus bytes, which no snapshot tool can then rewrite.
+ The generated documents (`crates/mega-state-test/DEVIATIONS.md`, `crates/mega-evm/tests/satin/pricing-table.md`, `bin/mega-evme/tests/satin-differences.md`) stay rendered by their tests and checked against the file, not snapshotted.
+- **Keep the execution-spec gate honest.**
+ A change that makes Satin's machinery differ from Ethereum's fixtures on purpose registers a deviation (its rule, its reason, the entries it fails with the hashes Satin produces for them) and regenerates `crates/mega-state-test/DEVIATIONS.md`; a failure that is a bug is fixed, never registered.
+ A price or a limit `MegaETH` sets is not a deviation: equivalence mode takes it out, and a new pricing or limit dimension extends the neutral configuration, or the limits the runner installs, rather than the registry.
- **Add benchmarks for performance-sensitive changes.**
Changes on the EVM execution hot path must be accompanied by benchmarks.
This includes new or modified opcode behavior, gas mechanics, system contract interception, resource limit tracking, and block executor pipeline changes.
@@ -309,30 +705,26 @@ When the agent is requested to implement a new feature or bug fix, it should con
- **Use `test_` prefix for Rust test function names.**
New `#[test]` functions should be named with a `test_` prefix for consistency with this repository and upstream revm style.
If editing nearby tests in the same module, align names to the same `test_` style when reasonable.
-- **Do NOT modify behavior for existing stable specs.**
- All specs through `REX6` are frozen; `REX7` is the unstable spec under active development.
- A spec being frozen is independent of whether any network has scheduled it — a frozen spec is off-limits to behavior changes whether or not a timestamp has been published.
- New EVM behavior, gas cost changes, or opcode modifications for stable specs **must** introduce a new spec and be gated with `spec.is_enabled(MegaSpecId::NEW_SPEC)`.
- Never change what an existing stable spec does.
-- **System contract changes require a new spec.**
- Do not modify system contract Solidity sources or their Rust integration without also introducing a new spec for backward compatibility.
-- **Override `HardforkParams::validate()` for every new params type.**
- The default implementation accepts any value silently.
- Override it with field-level invariant checks (e.g., non-zero addresses) so that `with_params()` panics loudly at chain-config load time rather than allowing the error to surface at the first block where the fork activates.
- Also register the fork-requires-params rule in `MegaHardforks::validate_schedule` so a schedule that activates the fork without its params fails validation, not the fork's first block.
-- **Pre-block helpers must return state, not commit directly.**
- Any helper participating in `pre_execution_changes` (system contract deploys, pre-block system calls, etc.) MUST return `Option` and never call `db.commit(...)` directly.
- Full convention: `crates/mega-evm/src/system/AGENTS.md` → `PRE-BLOCK STATE CHANGE CONTRACT`.
-- **Define value-transfer policy explicitly for system contract interceptors.**
- For read-only or control methods, reject calls with non-zero `transfer_value` in the interceptor.
- If a method intentionally accepts value, document the reason in spec and code comments and add dedicated tests.
-- **Do not intercept unknown selectors for system contracts.**
- Unknown selectors should fall through to on-chain bytecode and revert with a stable custom error such as `NotIntercepted()`.
-- **Only `CALL` and `STATICCALL` reach interceptor dispatch.**
- `CALLCODE` and `DELEGATECALL` are rejected by the call-scheme guard in `frame_init` before any interceptor is consulted.
- Do not expect these schemes to trigger system contract interception.
-- **System contract interceptor tests must cover boundary behaviors.**
- Include tests for normal intercepted path, non-zero value behavior, unknown selector fallback, and CALL vs DELEGATECALL/CALLCODE interception boundaries.
+- **System contracts carry over as they are.**
+ Satin reuses the Solidity sources and bindings in `crates/system-contracts`; changing a contract needs a decision of its own, not a side effect of an engine change.
+- **Rules for system contract interceptors.**
+ For read-only or control methods, reject calls with non-zero `transfer_value` in the interceptor; if a method intentionally accepts value, document the reason in spec and code comments and add dedicated tests.
+ Do not intercept unknown selectors: they fall through to the contract's own bytecode, where the two control contracts revert with `NotIntercepted()` and `KeylessDeploy` and the Oracle revert with empty data on a selector they do not declare.
+ Only `CALL` and `STATICCALL` reach interceptor dispatch; `CALLCODE` and `DELEGATECALL` are rejected by the call-scheme guard before any interceptor is consulted.
+ Interceptor tests cover the intercepted path, non-zero value, unknown selector fallback, and CALL vs DELEGATECALL/CALLCODE boundaries.
+- **Validate the schedule at load time.**
+ `MegaHardforks::validate_schedule` refuses a schedule a chain cannot run when the chain configuration is loaded rather than at the fork's first block.
+ It refuses a schedule in which a fork Satin runs on and the schedule activates by timestamp (Ethereum Shanghai to Osaka, Optimism Regolith to Karst) is not active at Satin's activation (`ScheduleError::InactiveBaseFork`); the engine's own schedules activate those forks from the first block, so they are active by `satinTime`, and pass.
+ That Jovian, Karst and Osaka do not activate before Satin is the node's to check, not the engine's.
+- **Keep the workspace on its declared minimum toolchain (1.94).**
+ CI's msrv job checks the workspace on 1.94.0, every feature on, with the lock as it is.
+ A dependency whose newer releases declare a newer compiler (alloy 2.2 and later declare 1.94.1) stays on the newest release the declared version builds: `.cargo/config.toml` sets the resolver's `incompatible-rust-versions = "fallback"`, so a `cargo update` run in the repository picks it.
+- **Pre-block helpers return their state and never commit.**
+ A helper that takes part in `apply_pre_execution_changes` (the activation block's check of the predeploys, the pre-block system calls, the registry's due-change read, the L1 block info read) never calls `db.commit(...)`: it returns the prepared state — an `EvmState`, or a `ResultAndState` for a system call — and the executor commits it on its own, in order, so the sequence of committed states is the witness a stateless client needs.
+ A read that changes nothing (a predeploy holding Satin's code, the L1 block info) returns `EvmState` that carries the observed account as a read-only entry: neither `touched` nor `created`.
+ Returning nothing there is a bug — the account disappears from the stateless witness read set.
+ A step that writes includes every account and storage slot it touched; a predeploy holding other code is an error, never an overwrite.
+ `system/predeploys.rs` holds the predeploy check, `block/eips.rs` the EIP-2935 and EIP-4788 calls, `system/sequencer_registry.rs` the registry's due-change read and its `applyPendingChanges()` call, `block/l1_block_info.rs` the L1 block info read, and the block executor is what commits them.
- **Respect `no_std` in `mega-evm` crate.**
Do not use `std::` directly.
Follow the existing pattern: `#[cfg(not(feature = "std"))] use alloc as std;` then `use std::{vec::Vec, ...};`.
@@ -354,8 +746,9 @@ When the agent is requested to implement a new feature or bug fix, it should con
- **Keep documentation up to date.**
When making changes, always check whether related documentation needs updating.
The primary documentation is in `docs/`.
+ `docs/spec/upgrades/satin.md` specifies Satin and is updated with any change to its behavior; the `docs/spec/evm/` and `docs/spec/system-contracts/` pages still describe the legacy engine.
The spec documentation is under `docs/spec/`, and the mega-evme documentation is under `docs/mega-evme/`.
- Also update this `AGENTS.md` when relevant (e.g., unstable spec marker, spec progression list, system contract table).
+ Also update this `AGENTS.md` when relevant (e.g., the module table, the unstable-spec marker).
- **One sentence, one line.**
When writing markdown or similar format files, put each sentence in a separate line.
- **Run Prettier on docs before committing.**
diff --git a/ARCH.md b/ARCH.md
index 2d289518d..3f5d87717 100644
--- a/ARCH.md
+++ b/ARCH.md
@@ -18,7 +18,8 @@ This document provides detailed technical specifications and implementation deta
The implementation exposes multiple EVM versions (`MegaSpecId`). String names and hardfork-to-spec
mapping live in `crates/mega-evm/src/evm/spec.rs` and `crates/mega-evm/src/block/hardfork.rs`.
-Available specs: `EQUIVALENCE`, `MINI_REX`, `MINI_REX_1`, `MINI_REX_2`, `REX`, `REX1`, `REX2`, `REX3`, `REX4`, `REX5`, `REX6`, `REX7` (`MINI_REX_1` and `MINI_REX_2` are alias rungs executing `EQUIVALENCE` and `MINI_REX` behavior respectively).
+The legacy engine's specs are `EQUIVALENCE`, `MINI_REX`, `MINI_REX_1`, `MINI_REX_2`, `REX`, `REX1`, `REX2`, `REX3`, `REX4`, `REX5`, `REX6` (`MINI_REX_1` and `MINI_REX_2` are alias rungs executing `EQUIVALENCE` and `MINI_REX` behavior respectively), and all of them are frozen.
+`SATIN` follows `REX6` and is the unstable spec; it is the only spec this crate executes.
This page details only the first few; the authoritative per-spec behavior is the specification under
`docs/spec/`, whose upgrade pages cover every spec.
diff --git a/Cargo.lock b/Cargo.lock
index 2b72f2d86..1eeebca2c 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -42,13 +42,13 @@ checksum = "683d7910e743518b0e34f1186f92494becacb047c7b6bf616c96772180fef923"
[[package]]
name = "alloy-chains"
-version = "0.2.6"
+version = "0.2.39"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4195a29a4b87137b2bb02105e746102873bc03561805cf45c0e510c961f160e6"
+checksum = "c1c4f6f6f020f38a4ef079428b5c7009e913bf8102e4d65a90c6cb2cf93800eb"
dependencies = [
"alloy-primitives",
"num_enum",
- "strum",
+ "phf 0.14.0",
]
[[package]]
@@ -57,12 +57,12 @@ version = "1.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "90d103d3e440ad6f703dd71a5b58a6abd24834563bde8a5fabe706e00242f810"
dependencies = [
- "alloy-eips",
+ "alloy-eips 1.8.3",
"alloy-primitives",
"alloy-rlp",
- "alloy-serde",
+ "alloy-serde 1.8.3",
"alloy-trie",
- "alloy-tx-macros",
+ "alloy-tx-macros 1.1.2",
"auto_impl",
"c-kzg",
"derive_more",
@@ -77,17 +77,58 @@ dependencies = [
"thiserror",
]
+[[package]]
+name = "alloy-consensus"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a6ff0c4adba2abdcd9fb5829ae5f4394c06f8585ed283a9ba79aa33763c802e1"
+dependencies = [
+ "alloy-eips 2.1.1",
+ "alloy-primitives",
+ "alloy-rlp",
+ "alloy-serde 2.1.1",
+ "alloy-trie",
+ "alloy-tx-macros 2.1.1",
+ "auto_impl",
+ "borsh",
+ "c-kzg",
+ "derive_more",
+ "either",
+ "k256",
+ "once_cell",
+ "rand 0.8.5",
+ "secp256k1 0.30.0",
+ "serde",
+ "serde_json",
+ "serde_with",
+ "thiserror",
+]
+
[[package]]
name = "alloy-consensus-any"
version = "1.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "48ead76c8c84ab3a50c31c56bc2c748c2d64357ad2131c32f9b10ab790a25e1a"
dependencies = [
- "alloy-consensus",
- "alloy-eips",
+ "alloy-consensus 1.1.0",
+ "alloy-eips 1.8.3",
+ "alloy-primitives",
+ "alloy-rlp",
+ "alloy-serde 1.8.3",
+ "serde",
+]
+
+[[package]]
+name = "alloy-consensus-any"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7cdf48932b1db3216175e19a2b476d89d53076e004850ee7983c6807ba0fde74"
+dependencies = [
+ "alloy-consensus 2.1.1",
+ "alloy-eips 2.1.1",
"alloy-primitives",
"alloy-rlp",
- "alloy-serde",
+ "alloy-serde 2.1.1",
"serde",
]
@@ -144,6 +185,20 @@ dependencies = [
"thiserror",
]
+[[package]]
+name = "alloy-eip7928"
+version = "0.4.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6a12e1dc70236cfb8e79b96dd8544aed47c39e2f45dc6b51c3703e969e052faa"
+dependencies = [
+ "alloy-primitives",
+ "alloy-rlp",
+ "borsh",
+ "once_cell",
+ "serde",
+ "thiserror",
+]
+
[[package]]
name = "alloy-eips"
version = "1.8.3"
@@ -153,10 +208,10 @@ dependencies = [
"alloy-eip2124",
"alloy-eip2930",
"alloy-eip7702",
- "alloy-eip7928",
+ "alloy-eip7928 0.3.7",
"alloy-primitives",
"alloy-rlp",
- "alloy-serde",
+ "alloy-serde 1.8.3",
"auto_impl",
"borsh",
"c-kzg",
@@ -167,25 +222,85 @@ dependencies = [
"sha2 0.10.9",
]
+[[package]]
+name = "alloy-eips"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ea4c0453065b9206acc0f869a258dc8dcbbd595e144b4446f2c493a24a814d1f"
+dependencies = [
+ "alloy-eip2124",
+ "alloy-eip2930",
+ "alloy-eip7702",
+ "alloy-eip7928 0.4.11",
+ "alloy-primitives",
+ "alloy-rlp",
+ "alloy-serde 2.1.1",
+ "auto_impl",
+ "borsh",
+ "c-kzg",
+ "derive_more",
+ "either",
+ "ethereum_ssz",
+ "ethereum_ssz_derive",
+ "serde",
+ "serde_with",
+ "sha2 0.10.9",
+]
+
[[package]]
name = "alloy-evm"
version = "0.15.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "28de0dd1bbb0634ef7c3715e8e60176b77b82f8b6b15b2e35fe64cf6640f6550"
dependencies = [
- "alloy-consensus",
- "alloy-eips",
- "alloy-hardforks",
+ "alloy-consensus 1.1.0",
+ "alloy-eips 1.8.3",
+ "alloy-hardforks 0.2.13",
"alloy-primitives",
"alloy-sol-types",
"auto_impl",
"derive_more",
- "op-alloy-consensus",
+ "op-alloy-consensus 0.18.14",
"op-revm 8.1.0",
"revm 27.1.0",
"thiserror",
]
+[[package]]
+name = "alloy-evm"
+version = "0.36.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a6e494529570a4d25eb4d1a7456d8f969c3202aceaf703e4006cec5f730aee96"
+dependencies = [
+ "alloy-consensus 2.1.1",
+ "alloy-eips 2.1.1",
+ "alloy-hardforks 0.4.8",
+ "alloy-primitives",
+ "alloy-rpc-types-engine",
+ "alloy-rpc-types-eth 2.1.1",
+ "alloy-sol-types",
+ "auto_impl",
+ "derive_more",
+ "revm 40.0.3",
+ "thiserror",
+ "tracing",
+]
+
+[[package]]
+name = "alloy-genesis"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "027ba57264c5d05e4ff52e6090b3592e7526f5d5f5a844add6bbdd17c071c911"
+dependencies = [
+ "alloy-eips 2.1.1",
+ "alloy-primitives",
+ "alloy-serde 2.1.1",
+ "alloy-trie",
+ "borsh",
+ "serde",
+ "serde_with",
+]
+
[[package]]
name = "alloy-hardforks"
version = "0.2.13"
@@ -199,11 +314,24 @@ dependencies = [
"dyn-clone",
]
+[[package]]
+name = "alloy-hardforks"
+version = "0.4.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "865371fb677c005f7cb0ea9c2847a1ba4fdb042caf6428b1769fee20368bbfc7"
+dependencies = [
+ "alloy-chains",
+ "alloy-eip2124",
+ "alloy-primitives",
+ "auto_impl",
+ "dyn-clone",
+]
+
[[package]]
name = "alloy-json-abi"
-version = "1.4.1"
+version = "1.6.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5513d5e6bd1cba6bdcf5373470f559f320c05c8c59493b6e98912fbe6733943f"
+checksum = "7c36c9d7f9021601b04bfef14a4b64849f6d73116a4e91e071d7fbfe10247901"
dependencies = [
"alloy-primitives",
"alloy-sol-type-parser",
@@ -226,22 +354,63 @@ dependencies = [
"tracing",
]
+[[package]]
+name = "alloy-json-rpc"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c4691c60de5d628533752cd07e102d17c47874c06c04c91af33960fd94c484f4"
+dependencies = [
+ "alloy-primitives",
+ "alloy-sol-types",
+ "http",
+ "serde",
+ "serde_json",
+ "thiserror",
+ "tracing",
+]
+
[[package]]
name = "alloy-network"
version = "1.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "612296e6b723470bb1101420a73c63dfd535aa9bf738ce09951aedbd4ab7292e"
dependencies = [
- "alloy-consensus",
- "alloy-consensus-any",
- "alloy-eips",
- "alloy-json-rpc",
- "alloy-network-primitives",
+ "alloy-consensus 1.1.0",
+ "alloy-consensus-any 1.1.0",
+ "alloy-eips 1.8.3",
+ "alloy-json-rpc 1.1.2",
+ "alloy-network-primitives 1.1.0",
"alloy-primitives",
- "alloy-rpc-types-any",
- "alloy-rpc-types-eth",
- "alloy-serde",
- "alloy-signer",
+ "alloy-rpc-types-any 1.1.0",
+ "alloy-rpc-types-eth 1.1.0",
+ "alloy-serde 1.8.3",
+ "alloy-signer 1.1.2",
+ "alloy-sol-types",
+ "async-trait",
+ "auto_impl",
+ "derive_more",
+ "futures-utils-wasm",
+ "serde",
+ "serde_json",
+ "thiserror",
+]
+
+[[package]]
+name = "alloy-network"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9d912bb639bf4ac31e83095afe9e907c8b9774ce0c405966228368309fcfc45f"
+dependencies = [
+ "alloy-consensus 2.1.1",
+ "alloy-consensus-any 2.1.1",
+ "alloy-eips 2.1.1",
+ "alloy-json-rpc 2.1.1",
+ "alloy-network-primitives 2.1.1",
+ "alloy-primitives",
+ "alloy-rpc-types-any 2.1.1",
+ "alloy-rpc-types-eth 2.1.1",
+ "alloy-serde 2.1.1",
+ "alloy-signer 2.1.1",
"alloy-sol-types",
"async-trait",
"auto_impl",
@@ -258,10 +427,23 @@ version = "1.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a0e7918396eecd69d9c907046ec8a93fb09b89e2f325d5e7ea9c4e3929aa0dd2"
dependencies = [
- "alloy-consensus",
- "alloy-eips",
+ "alloy-consensus 1.1.0",
+ "alloy-eips 1.8.3",
"alloy-primitives",
- "alloy-serde",
+ "alloy-serde 1.8.3",
+ "serde",
+]
+
+[[package]]
+name = "alloy-network-primitives"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d875a11bd98595f57f73890f2e36f4a1cca0fa670623e59c9fb08b2389979c36"
+dependencies = [
+ "alloy-consensus 2.1.1",
+ "alloy-eips 2.1.1",
+ "alloy-primitives",
+ "alloy-serde 2.1.1",
"serde",
]
@@ -271,17 +453,34 @@ version = "0.15.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0afe768962308a08b42fddef8a4296324f140b5a8dd0d4360038229885ce9434"
dependencies = [
- "alloy-consensus",
- "alloy-eips",
- "alloy-evm",
- "alloy-op-hardforks",
+ "alloy-consensus 1.1.0",
+ "alloy-eips 1.8.3",
+ "alloy-evm 0.15.0",
+ "alloy-op-hardforks 0.2.13",
"alloy-primitives",
"auto_impl",
- "op-alloy-consensus",
+ "op-alloy-consensus 0.18.14",
"op-revm 8.1.0",
"revm 27.1.0",
]
+[[package]]
+name = "alloy-op-evm"
+version = "0.32.0"
+source = "git+https://github.com/ethereum-optimism/optimism?rev=f67d87cd5c9992b62d215c043917b94e3f019629#f67d87cd5c9992b62d215c043917b94e3f019629"
+dependencies = [
+ "alloy-consensus 2.1.1",
+ "alloy-eips 2.1.1",
+ "alloy-evm 0.36.0",
+ "alloy-op-hardforks 0.5.0",
+ "alloy-primitives",
+ "auto_impl",
+ "op-alloy",
+ "op-revm 20.0.0",
+ "revm 40.0.3",
+ "thiserror",
+]
+
[[package]]
name = "alloy-op-hardforks"
version = "0.2.13"
@@ -289,7 +488,18 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3417f4187eaf7f7fb0d7556f0197bca26f0b23c4bb3aca0c9d566dc1c5d727a2"
dependencies = [
"alloy-chains",
- "alloy-hardforks",
+ "alloy-hardforks 0.2.13",
+ "auto_impl",
+]
+
+[[package]]
+name = "alloy-op-hardforks"
+version = "0.5.0"
+source = "git+https://github.com/ethereum-optimism/optimism?rev=f67d87cd5c9992b62d215c043917b94e3f019629#f67d87cd5c9992b62d215c043917b94e3f019629"
+dependencies = [
+ "alloy-chains",
+ "alloy-hardforks 0.4.8",
+ "alloy-primitives",
"auto_impl",
]
@@ -328,18 +538,59 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "55c1313a527a2e464d067c031f3c2ec073754ef615cc0eabca702fd0fe35729c"
dependencies = [
"alloy-chains",
- "alloy-consensus",
- "alloy-eips",
- "alloy-json-rpc",
- "alloy-network",
- "alloy-network-primitives",
+ "alloy-consensus 1.1.0",
+ "alloy-eips 1.8.3",
+ "alloy-json-rpc 1.1.2",
+ "alloy-network 1.1.0",
+ "alloy-network-primitives 1.1.0",
+ "alloy-primitives",
+ "alloy-rpc-client 1.1.2",
+ "alloy-rpc-types-eth 1.1.0",
+ "alloy-signer 1.1.2",
+ "alloy-sol-types",
+ "alloy-transport 1.1.2",
+ "alloy-transport-http 1.1.2",
+ "async-stream",
+ "async-trait",
+ "auto_impl",
+ "dashmap",
+ "either",
+ "futures",
+ "futures-utils-wasm",
+ "lru 0.13.0",
+ "parking_lot",
+ "pin-project",
+ "reqwest 0.12.24",
+ "serde",
+ "serde_json",
+ "thiserror",
+ "tokio",
+ "tracing",
+ "url",
+ "wasmtimer",
+]
+
+[[package]]
+name = "alloy-provider"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0e7d526d184d392a8fbcf4293e457789b307bb70646e4f8b902989a246529450"
+dependencies = [
+ "alloy-chains",
+ "alloy-consensus 2.1.1",
+ "alloy-eips 2.1.1",
+ "alloy-json-rpc 2.1.1",
+ "alloy-network 2.1.1",
+ "alloy-network-primitives 2.1.1",
"alloy-primitives",
- "alloy-rpc-client",
- "alloy-rpc-types-eth",
- "alloy-signer",
+ "alloy-rpc-client 2.1.1",
+ "alloy-rpc-types-debug",
+ "alloy-rpc-types-eth 2.1.1",
+ "alloy-rpc-types-trace 2.1.1",
+ "alloy-signer 2.1.1",
"alloy-sol-types",
- "alloy-transport",
- "alloy-transport-http",
+ "alloy-transport 2.1.1",
+ "alloy-transport-http 2.1.1",
"async-stream",
"async-trait",
"auto_impl",
@@ -347,10 +598,10 @@ dependencies = [
"either",
"futures",
"futures-utils-wasm",
- "lru",
+ "lru 0.16.4",
"parking_lot",
"pin-project",
- "reqwest",
+ "reqwest 0.13.5",
"serde",
"serde_json",
"thiserror",
@@ -362,9 +613,9 @@ dependencies = [
[[package]]
name = "alloy-rlp"
-version = "0.3.12"
+version = "0.3.16"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5f70d83b765fdc080dbcd4f4db70d8d23fe4761f2f02ebfa9146b833900634b4"
+checksum = "24671b1f62edcf0f9b62994c7bf72cd621a04a4b99f5020ece1a647b40e2f103"
dependencies = [
"alloy-rlp-derive",
"arrayvec",
@@ -373,9 +624,9 @@ dependencies = [
[[package]]
name = "alloy-rlp-derive"
-version = "0.3.12"
+version = "0.3.16"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "64b728d511962dda67c1bc7ea7c03736ec275ed2cf4c35d9585298ac9ccf3b73"
+checksum = "9d4311c03125e8a18296504560b9de3d75ecbd0dcda7f71e6cf2a196d57e6fba"
dependencies = [
"proc-macro2",
"quote",
@@ -388,13 +639,36 @@ version = "1.1.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "31c89883fe6b7381744cbe80fef638ac488ead4f1956a4278956a1362c71cd2e"
dependencies = [
- "alloy-json-rpc",
+ "alloy-json-rpc 1.1.2",
+ "alloy-primitives",
+ "alloy-transport 1.1.2",
+ "alloy-transport-http 1.1.2",
+ "futures",
+ "pin-project",
+ "reqwest 0.12.24",
+ "serde",
+ "serde_json",
+ "tokio",
+ "tokio-stream",
+ "tower",
+ "tracing",
+ "url",
+ "wasmtimer",
+]
+
+[[package]]
+name = "alloy-rpc-client"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "755447dc13a04c6fa6db8dedb5d32ab5edfa4dd7aa34487ff192a3d873e0e8cf"
+dependencies = [
+ "alloy-json-rpc 2.1.1",
"alloy-primitives",
- "alloy-transport",
- "alloy-transport-http",
+ "alloy-transport 2.1.1",
+ "alloy-transport-http 2.1.1",
"futures",
"pin-project",
- "reqwest",
+ "reqwest 0.13.5",
"serde",
"serde_json",
"tokio",
@@ -411,9 +685,56 @@ version = "1.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "cdbf6d1766ca41e90ac21c4bc5cbc5e9e965978a25873c3f90b3992d905db4cb"
dependencies = [
- "alloy-consensus-any",
- "alloy-rpc-types-eth",
- "alloy-serde",
+ "alloy-consensus-any 1.1.0",
+ "alloy-rpc-types-eth 1.1.0",
+ "alloy-serde 1.8.3",
+]
+
+[[package]]
+name = "alloy-rpc-types-any"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "911a513723ef0b90c3b072f65eebf54d6ebc8b651d06734e252d024bd89b88ac"
+dependencies = [
+ "alloy-consensus-any 2.1.1",
+ "alloy-network-primitives 2.1.1",
+ "alloy-primitives",
+ "alloy-rpc-types-eth 2.1.1",
+ "alloy-serde 2.1.1",
+ "serde",
+ "serde_json",
+]
+
+[[package]]
+name = "alloy-rpc-types-debug"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b9e9c1f9ac81c56b2d96901201db7eb95c4e9fc3c21237a4690f8c652aa62089"
+dependencies = [
+ "alloy-primitives",
+ "alloy-rlp",
+ "derive_more",
+ "serde",
+ "serde_with",
+]
+
+[[package]]
+name = "alloy-rpc-types-engine"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5b1f682c4881aa7000ac7cc86d7aeeb3b09836a77a90b329820140233651aeea"
+dependencies = [
+ "alloy-consensus 2.1.1",
+ "alloy-eips 2.1.1",
+ "alloy-primitives",
+ "alloy-rlp",
+ "alloy-serde 2.1.1",
+ "derive_more",
+ "ethereum_ssz",
+ "ethereum_ssz_derive",
+ "rand 0.8.5",
+ "serde",
+ "strum",
]
[[package]]
@@ -422,13 +743,34 @@ version = "1.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a15e4831b71eea9d20126a411c1c09facf1d01d5cac84fd51d532d3c429cfc26"
dependencies = [
- "alloy-consensus",
- "alloy-consensus-any",
- "alloy-eips",
- "alloy-network-primitives",
+ "alloy-consensus 1.1.0",
+ "alloy-consensus-any 1.1.0",
+ "alloy-eips 1.8.3",
+ "alloy-network-primitives 1.1.0",
"alloy-primitives",
"alloy-rlp",
- "alloy-serde",
+ "alloy-serde 1.8.3",
+ "alloy-sol-types",
+ "itertools 0.14.0",
+ "serde",
+ "serde_json",
+ "serde_with",
+ "thiserror",
+]
+
+[[package]]
+name = "alloy-rpc-types-eth"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4e1bd19904581ee2075b61faabab1a4cefa8b96d8f2c85343adeae8ecf615e2b"
+dependencies = [
+ "alloy-consensus 2.1.1",
+ "alloy-consensus-any 2.1.1",
+ "alloy-eips 2.1.1",
+ "alloy-network-primitives 2.1.1",
+ "alloy-primitives",
+ "alloy-rlp",
+ "alloy-serde 2.1.1",
"alloy-sol-types",
"itertools 0.14.0",
"serde",
@@ -444,8 +786,22 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d6a854af3fe8fce1cfe319fcf84ee8ba8cda352b14d3dd4221405b5fc6cce9e1"
dependencies = [
"alloy-primitives",
- "alloy-rpc-types-eth",
- "alloy-serde",
+ "alloy-rpc-types-eth 1.1.0",
+ "alloy-serde 1.8.3",
+ "serde",
+ "serde_json",
+ "thiserror",
+]
+
+[[package]]
+name = "alloy-rpc-types-trace"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "796729a4e1783904c6040f11a503c4d55ddb16f69dc199ad15e50c4ad039f371"
+dependencies = [
+ "alloy-primitives",
+ "alloy-rpc-types-eth 2.1.1",
+ "alloy-serde 2.1.1",
"serde",
"serde_json",
"thiserror",
@@ -462,6 +818,17 @@ dependencies = [
"serde_json",
]
+[[package]]
+name = "alloy-serde"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c1e97b3e0b9f816b25083045dcfa69431bd059a078e828e4d82d296d1949b96c"
+dependencies = [
+ "alloy-primitives",
+ "serde",
+ "serde_json",
+]
+
[[package]]
name = "alloy-signer"
version = "1.1.2"
@@ -477,11 +844,26 @@ dependencies = [
"thiserror",
]
+[[package]]
+name = "alloy-signer"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6913d06ccc0d9c6ab67e2f82e2fbe292706da1f91442f30cded2d04b56bf0d58"
+dependencies = [
+ "alloy-primitives",
+ "async-trait",
+ "auto_impl",
+ "either",
+ "elliptic-curve",
+ "k256",
+ "thiserror",
+]
+
[[package]]
name = "alloy-sol-macro"
-version = "1.4.1"
+version = "1.6.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f3ce480400051b5217f19d6e9a82d9010cdde20f1ae9c00d53591e4a1afbb312"
+checksum = "840128ed2b2971d6d4668a553fe403a82683d3acc646c73e75887e7157408033"
dependencies = [
"alloy-sol-macro-expander",
"alloy-sol-macro-input",
@@ -493,9 +875,9 @@ dependencies = [
[[package]]
name = "alloy-sol-macro-expander"
-version = "1.4.1"
+version = "1.6.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6d792e205ed3b72f795a8044c52877d2e6b6e9b1d13f431478121d8d4eaa9028"
+checksum = "63ec265e5d65d725175f6ca7711c970824c90ef9c0d1f1973711d4150ee612dd"
dependencies = [
"alloy-sol-macro-input",
"const-hex",
@@ -504,16 +886,16 @@ dependencies = [
"proc-macro-error2",
"proc-macro2",
"quote",
+ "sha3",
"syn 2.0.104",
"syn-solidity",
- "tiny-keccak",
]
[[package]]
name = "alloy-sol-macro-input"
-version = "1.4.1"
+version = "1.6.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0bd1247a8f90b465ef3f1207627547ec16940c35597875cdc09c49d58b19693c"
+checksum = "89bf01077f18650876cfa682eb1f949967b5cde03f1a51c955c469d2c9b4aa67"
dependencies = [
"const-hex",
"dunce",
@@ -527,19 +909,19 @@ dependencies = [
[[package]]
name = "alloy-sol-type-parser"
-version = "1.4.1"
+version = "1.6.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "954d1b2533b9b2c7959652df3076954ecb1122a28cc740aa84e7b0a49f6ac0a9"
+checksum = "857b470ecdd2ed38beaf82ad1a38c516a8ff75266750f38b9eeed001d575241b"
dependencies = [
"serde",
- "winnow",
+ "winnow 1.0.4",
]
[[package]]
name = "alloy-sol-types"
-version = "1.4.1"
+version = "1.6.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "70319350969a3af119da6fb3e9bddb1bce66c9ea933600cb297c8b1850ad2a3c"
+checksum = "384cf252de0db2dec52821eac037a7f57e2aa33fe5b900ce6fe39973402341f1"
dependencies = [
"alloy-json-abi",
"alloy-primitives",
@@ -553,9 +935,32 @@ version = "1.1.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "cae82426d98f8bc18f53c5223862907cac30ab8fc5e4cd2bb50808e6d3ab43d8"
dependencies = [
- "alloy-json-rpc",
+ "alloy-json-rpc 1.1.2",
+ "auto_impl",
+ "base64 0.22.1",
+ "derive_more",
+ "futures",
+ "futures-utils-wasm",
+ "parking_lot",
+ "serde",
+ "serde_json",
+ "thiserror",
+ "tokio",
+ "tower",
+ "tracing",
+ "url",
+ "wasmtimer",
+]
+
+[[package]]
+name = "alloy-transport"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "999adfe5c91035c6bf4c4210e0eb8d0caed79d76fbf5e1b70d78721f6097ac04"
+dependencies = [
+ "alloy-json-rpc 2.1.1",
"auto_impl",
- "base64",
+ "base64 0.22.1",
"derive_more",
"futures",
"futures-utils-wasm",
@@ -576,9 +981,25 @@ version = "1.1.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "90aa6825760905898c106aba9c804b131816a15041523e80b6d4fe7af6380ada"
dependencies = [
- "alloy-json-rpc",
- "alloy-transport",
- "reqwest",
+ "alloy-json-rpc 1.1.2",
+ "alloy-transport 1.1.2",
+ "reqwest 0.12.24",
+ "serde_json",
+ "tower",
+ "tracing",
+ "url",
+]
+
+[[package]]
+name = "alloy-transport-http"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0e79a2c1793afc61eed9ca0963da370a988b27d2bbfa67c78013e262d47424c4"
+dependencies = [
+ "alloy-json-rpc 2.1.1",
+ "alloy-transport 2.1.1",
+ "itertools 0.14.0",
+ "reqwest 0.13.5",
"serde_json",
"tower",
"tracing",
@@ -587,17 +1008,17 @@ dependencies = [
[[package]]
name = "alloy-trie"
-version = "0.9.0"
+version = "0.9.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bada1fc392a33665de0dc50d401a3701b62583c655e3522a323490a5da016962"
+checksum = "3f14b5d9b2c2173980202c6ff470d96e7c5e202c65a9f67884ad565226df7fbb"
dependencies = [
"alloy-primitives",
"alloy-rlp",
- "arrayvec",
"derive_more",
"nybbles",
"serde",
"smallvec",
+ "thiserror",
"tracing",
]
@@ -607,7 +1028,19 @@ version = "1.1.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ae109e33814b49fc0a62f2528993aa8a2dd346c26959b151f05441dc0b9da292"
dependencies = [
- "darling",
+ "darling 0.21.3",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.104",
+]
+
+[[package]]
+name = "alloy-tx-macros"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "406bc1183f6843e0aba09f7b3365e828b597213d60793ba5cb41befc863e3a78"
+dependencies = [
+ "darling 0.23.0",
"proc-macro2",
"quote",
"syn 2.0.104",
@@ -1000,9 +1433,6 @@ name = "arrayvec"
version = "0.7.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7c02d123df017efcdfbd739ef81735b36c5ba83ec3c59c80a9d7ecc718f92e50"
-dependencies = [
- "serde",
-]
[[package]]
name = "assert-json-diff"
@@ -1038,13 +1468,13 @@ dependencies = [
[[package]]
name = "async-trait"
-version = "0.1.89"
+version = "0.1.92"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9035ad2d096bed7955a320ee7e2230574d28fd3c3a0f186cbea1ff3c7eed5dbb"
+checksum = "82f6aeea286b8eb4dd3431a1be1b59d290ace00f5bfd8e2a159bc2a05e2c1667"
dependencies = [
"proc-macro2",
"quote",
- "syn 2.0.104",
+ "syn 3.0.6",
]
[[package]]
@@ -1098,6 +1528,12 @@ version = "0.22.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6"
+[[package]]
+name = "base64"
+version = "0.23.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac07cdecf99051d9a5238b80f35af32cdeba5b336e55d957b318b50137e18da5"
+
[[package]]
name = "base64ct"
version = "1.8.0"
@@ -1144,6 +1580,12 @@ dependencies = [
"hex-conservative",
]
+[[package]]
+name = "bitflags"
+version = "1.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
+
[[package]]
name = "bitflags"
version = "2.11.1"
@@ -1242,6 +1684,15 @@ dependencies = [
"syn 2.0.104",
]
+[[package]]
+name = "bs58"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bf88ba1141d185c399bee5288d850d63b8369520c1eafc32a0430b5b6c287bf4"
+dependencies = [
+ "tinyvec",
+]
+
[[package]]
name = "bumpalo"
version = "3.19.0"
@@ -1297,6 +1748,8 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f5d6cac793997bd970000024b2934968efe83b382de4fdcf4fcb46b6ee4ad996"
dependencies = [
"find-msvc-tools",
+ "jobserver",
+ "libc",
"shlex",
]
@@ -1312,17 +1765,6 @@ version = "0.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "613afe47fcd5fac7ccf1db93babcb082c5994d996f20b8b159f2ad1658eb5724"
-[[package]]
-name = "chacha20"
-version = "0.10.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d524456ba66e72eb8b115ff89e01e497f8e6d11d78b70b1aa13c0fbd97540a81"
-dependencies = [
- "cfg-if",
- "cpufeatures 0.3.0",
- "rand_core 0.10.1",
-]
-
[[package]]
name = "chrono"
version = "0.4.41"
@@ -1472,7 +1914,7 @@ version = "3.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "faf9468729b8cbcea668e36183cb69d317348c2e08e994829fb56ebfdfbaac34"
dependencies = [
- "windows-sys 0.61.2",
+ "windows-sys 0.59.0",
]
[[package]]
@@ -1534,9 +1976,9 @@ checksum = "7c74b8349d32d297c9134b8c88677813a227df8f779daa29bfc29c183fe3dca6"
[[package]]
name = "convert_case"
-version = "0.7.1"
+version = "0.10.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bb402b8d4c85569410425650ce3eddc7d698ed96d39a73f941b08fb63082f1e7"
+checksum = "633458d4ef8c78b72454de2d54fd6ab2e60f9e02be22f3c6104cdc8a4e0fceb9"
dependencies = [
"unicode-segmentation",
]
@@ -1600,11 +2042,17 @@ dependencies = [
"itertools 0.10.5",
]
+[[package]]
+name = "critical-section"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "790eea4361631c5e7d22598ecd5723ff611904e3344ce8720784c93e3d83d40b"
+
[[package]]
name = "crossbeam-utils"
-version = "0.8.21"
+version = "0.8.23"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28"
+checksum = "a31eee39dddec8330830986fcd7625edb5a24ec90ea038215273bbc3adb08ac6"
[[package]]
name = "crunchy"
@@ -1649,8 +2097,28 @@ version = "0.21.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9cdf337090841a411e2a7f3deb9187445851f91b309c0c0a29e05f74a00a48c0"
dependencies = [
- "darling_core",
- "darling_macro",
+ "darling_core 0.21.3",
+ "darling_macro 0.21.3",
+]
+
+[[package]]
+name = "darling"
+version = "0.23.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "25ae13da2f202d56bd7f91c25fba009e7717a1e4a1cc98a76d844b65ae912e9d"
+dependencies = [
+ "darling_core 0.23.0",
+ "darling_macro 0.23.0",
+]
+
+[[package]]
+name = "darling"
+version = "0.24.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed17f5901b6630b993ca003def43f2f8ef4014fc13b047b57aad617ff32bc2ec"
+dependencies = [
+ "darling_core 0.24.1",
+ "darling_macro 0.24.1",
]
[[package]]
@@ -1668,17 +2136,66 @@ dependencies = [
"syn 2.0.104",
]
+[[package]]
+name = "darling_core"
+version = "0.23.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9865a50f7c335f53564bb694ef660825eb8610e0a53d3e11bf1b0d3df31e03b0"
+dependencies = [
+ "ident_case",
+ "proc-macro2",
+ "quote",
+ "serde",
+ "strsim",
+ "syn 2.0.104",
+]
+
+[[package]]
+name = "darling_core"
+version = "0.24.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6837e2cf7485aaae18f86181d2f0e9a7ed297a025e220aeabf63fdebd3a2ddff"
+dependencies = [
+ "ident_case",
+ "proc-macro2",
+ "quote",
+ "strsim",
+ "syn 3.0.6",
+]
+
[[package]]
name = "darling_macro"
version = "0.21.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d38308df82d1080de0afee5d069fa14b0326a88c14f15c5ccda35b4a6c414c81"
dependencies = [
- "darling_core",
+ "darling_core 0.21.3",
+ "quote",
+ "syn 2.0.104",
+]
+
+[[package]]
+name = "darling_macro"
+version = "0.23.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac3984ec7bd6cfa798e62b4a642426a5be0e68f9401cfc2a01e3fa9ea2fcdb8d"
+dependencies = [
+ "darling_core 0.23.0",
"quote",
"syn 2.0.104",
]
+[[package]]
+name = "darling_macro"
+version = "0.24.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2ac7135c3ef02b2f7833bbeb1be5ba7f966dcde8a87c6b87f65a778d71a02785"
+dependencies = [
+ "darling_core 0.24.1",
+ "quote",
+ "syn 3.0.6",
+]
+
[[package]]
name = "dashmap"
version = "6.1.0"
@@ -1711,6 +2228,37 @@ version = "0.1.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "092966b41edc516079bdf31ec78a2e0588d1d0c08f78b91d8307215928642b2b"
+[[package]]
+name = "defmt"
+version = "1.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e2953bfe4f93bbd20cc71198842756f77d161884c99ebbabc41d80231ded88d1"
+dependencies = [
+ "bitflags 1.3.2",
+ "defmt-macros",
+]
+
+[[package]]
+name = "defmt-macros"
+version = "1.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bad9c72e7ca2137e0dc3813245a0d282fd6daad32fd800af018306a9169b5fe8"
+dependencies = [
+ "defmt-parser",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.104",
+]
+
+[[package]]
+name = "defmt-parser"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "10d60334b3b2e7c9d91ef8150abfb6fa4c1c39ebbcf4a81c2e346aad939fee3e"
+dependencies = [
+ "thiserror",
+]
+
[[package]]
name = "delegate"
version = "0.13.4"
@@ -1766,22 +2314,23 @@ dependencies = [
[[package]]
name = "derive_more"
-version = "2.0.1"
+version = "2.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "093242cf7570c207c83073cf82f79706fe7b8317e98620a47d5be7c3d8497678"
+checksum = "d751e9e49156b02b44f9c1815bcb94b984cdcc4396ecc32521c739452808b134"
dependencies = [
"derive_more-impl",
]
[[package]]
name = "derive_more-impl"
-version = "2.0.1"
+version = "2.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bda628edc44c4bb645fbe0f758797143e4e07926f7ebf4e9bdfbd3d2ce621df3"
+checksum = "799a97264921d8623a957f6c3b9011f3b5492f557bbb7a5a19b7fa6d06ba8dcb"
dependencies = [
"convert_case",
"proc-macro2",
"quote",
+ "rustc_version 0.4.1",
"syn 2.0.104",
"unicode-xid",
]
@@ -1835,18 +2384,18 @@ dependencies = [
"libc",
"option-ext",
"redox_users",
- "windows-sys 0.61.2",
+ "windows-sys 0.59.0",
]
[[package]]
name = "displaydoc"
-version = "0.2.5"
+version = "0.2.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "97369cbbc041bc366949bc74d34658d6cda5621039731c6310521892a3a20ae0"
+checksum = "c6232dd377dcc64799954cbd3a9bb882e9cdc1308ccd87b1c098f1fb2eaf82a8"
dependencies = [
"proc-macro2",
"quote",
- "syn 2.0.104",
+ "syn 3.0.6",
]
[[package]]
@@ -1965,7 +2514,47 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "778e2ac28f6c47af28e4907f13ffd1e1ddbd400980a9abd7c8df189bf578a5ad"
dependencies = [
"libc",
- "windows-sys 0.60.2",
+ "windows-sys 0.59.0",
+]
+
+[[package]]
+name = "ethereum_serde_utils"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "38df44a7a271ab43835678f9215b53cc2523e4714a215da6643d83dc110245da"
+dependencies = [
+ "alloy-primitives",
+ "hex",
+ "serde",
+ "serde_derive",
+ "serde_json",
+]
+
+[[package]]
+name = "ethereum_ssz"
+version = "0.10.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e462875ad8693755ea8913d6e905715c76ea4836e2254e18c9cf0f7a8f8c2a13"
+dependencies = [
+ "alloy-primitives",
+ "ethereum_serde_utils",
+ "itertools 0.14.0",
+ "serde",
+ "serde_derive",
+ "smallvec",
+ "typenum",
+]
+
+[[package]]
+name = "ethereum_ssz_derive"
+version = "0.10.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "daf022360bdbe9456eda5f35718a50476d5b2a0d51a97ed4eae27420737a6fba"
+dependencies = [
+ "darling 0.23.0",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.104",
]
[[package]]
@@ -2091,9 +2680,9 @@ checksum = "e6d5a32815ae3f33302d95fdcb2ce17862f8c65363dcfd29360480ba1001fc9c"
[[package]]
name = "futures"
-version = "0.3.31"
+version = "0.3.34"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "65bc07b1a8bc7c85c5f2e110c476c7389b4554ba72af57d8445ea63a576b0876"
+checksum = "9a31d2a3fbaaeb2af2368bbdd904aa8e812d3c04a1ee10d3171f52d556e5d0a3"
dependencies = [
"futures-channel",
"futures-core",
@@ -2106,9 +2695,9 @@ dependencies = [
[[package]]
name = "futures-channel"
-version = "0.3.31"
+version = "0.3.34"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2dff15bf788c671c1934e366d07e30c1814a8ef514e1af724a602e8a2fbe1b10"
+checksum = "b1f9e3d69d39e4862ffed03ed071a76f9a13ba1d9109d355b0f0aa6b15e393c4"
dependencies = [
"futures-core",
"futures-sink",
@@ -2116,15 +2705,15 @@ dependencies = [
[[package]]
name = "futures-core"
-version = "0.3.31"
+version = "0.3.34"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "05f29059c0c2090612e8d742178b0580d2dc940c837851ad723096f87af6663e"
+checksum = "92d699e522242e69e3003b94ecc1f960f3a5e015aa7c5d7486e65ad01dd94f5e"
[[package]]
name = "futures-executor"
-version = "0.3.31"
+version = "0.3.34"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1e28d1d997f585e54aebc3f97d39e72338912123a67330d723fdbb564d646c9f"
+checksum = "031b47cf1a3c6cc8bc2fc76cd437f521619387907d469316e7c0bc278f1f5432"
dependencies = [
"futures-core",
"futures-task",
@@ -2133,38 +2722,38 @@ dependencies = [
[[package]]
name = "futures-io"
-version = "0.3.31"
+version = "0.3.34"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9e5c1b78ca4aae1ac06c48a526a655760685149f0d465d21f37abfe57ce075c6"
+checksum = "53c0fa8157de1303bfffdaa1cc2a673bfffb60102f76b0ef4441659124373fed"
[[package]]
name = "futures-macro"
-version = "0.3.31"
+version = "0.3.34"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "162ee34ebcb7c64a8abebc059ce0fee27c2262618d7b60ed8faf72fef13c3650"
+checksum = "9fb9654ba8355388abeb8dcb4fc62f511300867002afc858860463bdd9fe0c44"
dependencies = [
"proc-macro2",
"quote",
- "syn 2.0.104",
+ "syn 3.0.6",
]
[[package]]
name = "futures-sink"
-version = "0.3.31"
+version = "0.3.34"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e575fab7d1e0dcb8d0c7bcf9a63ee213816ab51902e6d244a95819acacf1d4f7"
+checksum = "1944426bf7d03f1d14f708785e4b33efd750b36d48a157b836b3efc15ede8e1d"
[[package]]
name = "futures-task"
-version = "0.3.31"
+version = "0.3.34"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f90f7dce0722e95104fcb095585910c0977252f286e354b5e3bd38902cd99988"
+checksum = "cd417de3d1d015fc3bfd2b1ea46dfc7bab72ef86f1cc7cc9c78e728b34a6d1fd"
[[package]]
name = "futures-util"
-version = "0.3.31"
+version = "0.3.34"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9fa08315bb612088cc391249efdc3bc77536f16c91f6cf495e6fbe85b20a4a81"
+checksum = "0d50a92467f8ba5dd6e3ee5d4bd04d73ab2e4e1c44474a0674821dfce14b79bc"
dependencies = [
"futures-channel",
"futures-core",
@@ -2174,7 +2763,6 @@ dependencies = [
"futures-task",
"memchr",
"pin-project-lite",
- "pin-utils",
"slab",
]
@@ -2233,7 +2821,6 @@ dependencies = [
"cfg-if",
"libc",
"r-efi 6.0.0",
- "rand_core 0.10.1",
]
[[package]]
@@ -2265,9 +2852,9 @@ dependencies = [
[[package]]
name = "h2"
-version = "0.4.12"
+version = "0.4.19"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f3c0b69cfcb4e1b9f1bf2f53f95f766e4661169728ec61cd3fe5a0166f2d1386"
+checksum = "ef8e5e5a340588f4452631496976cf8636d4a7ecf600239fdc27615d2530bc16"
dependencies = [
"atomic-waker",
"bytes",
@@ -2321,6 +2908,17 @@ dependencies = [
"foldhash 0.1.5",
]
+[[package]]
+name = "hashbrown"
+version = "0.16.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "841d1cc9bed7f9236f321df977030373f4a4163ae1a7dbfe1a51a2c1a51d9100"
+dependencies = [
+ "allocator-api2",
+ "equivalent",
+ "foldhash 0.2.0",
+]
+
[[package]]
name = "hashbrown"
version = "0.17.1"
@@ -2373,20 +2971,19 @@ dependencies = [
[[package]]
name = "http"
-version = "1.3.1"
+version = "1.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f4a85d31aea989eead29a3aaf9e1115a180df8282431156e533de47660892565"
+checksum = "918d3568bebf352712bc2ef3d46a8bcf1a75b373be6539de198e9105cbbf9ce0"
dependencies = [
"bytes",
- "fnv",
"itoa",
]
[[package]]
name = "http-body"
-version = "1.0.1"
+version = "1.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1efedce1fb8e6913f23e0c92de8e62cd5b772a67e7b3946df930a62566c93184"
+checksum = "ca2a8f2913ee65f60facd6a5905613afaa448497a0230cc41ce022d93290bc2c"
dependencies = [
"bytes",
"http",
@@ -2394,9 +2991,9 @@ dependencies = [
[[package]]
name = "http-body-util"
-version = "0.1.3"
+version = "0.1.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b021d93e26becf5dc7e1b75b1bed1fd93124b374ceb73f43d4d4eafec896a64a"
+checksum = "23169fe34a5fbcdd3f3862e78fb9b6fccd5f02a6dc6f732547005d45631ce71c"
dependencies = [
"bytes",
"futures-core",
@@ -2428,9 +3025,9 @@ dependencies = [
[[package]]
name = "hyper"
-version = "1.8.0"
+version = "1.11.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1744436df46f0bde35af3eda22aeaba453aada65d8f1c171cd8a5f59030bd69f"
+checksum = "27b501faa50e7a26c3d3560ca625132f4078a17771f4810baf70475ae48cbe43"
dependencies = [
"atomic-waker",
"bytes",
@@ -2443,7 +3040,6 @@ dependencies = [
"httpdate",
"itoa",
"pin-project-lite",
- "pin-utils",
"smallvec",
"tokio",
"want",
@@ -2483,14 +3079,13 @@ dependencies = [
[[package]]
name = "hyper-util"
-version = "0.1.17"
+version = "0.1.20"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3c6995591a8f1380fcb4ba966a252a4b29188d51d2b89e3a252f5305be65aea8"
+checksum = "96547c2556ec9d12fb1578c4eaf448b04993e7fb79cbaad930a656880a6bdfa0"
dependencies = [
- "base64",
+ "base64 0.22.1",
"bytes",
"futures-channel",
- "futures-core",
"futures-util",
"http",
"http-body",
@@ -2533,12 +3128,13 @@ dependencies = [
[[package]]
name = "icu_collections"
-version = "2.1.1"
+version = "2.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4c6b649701667bbe825c3b7e6388cb521c23d88644678e83c0c4d0a621a34b43"
+checksum = "fa68d21081c4a05d5a901a1c62add574c77048b6a1c67be3b50ce0b60d4ca513"
dependencies = [
"displaydoc",
"potential_utf",
+ "utf8_iter",
"yoke",
"zerofrom",
"zerovec",
@@ -2546,9 +3142,9 @@ dependencies = [
[[package]]
name = "icu_locale_core"
-version = "2.1.1"
+version = "2.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "edba7861004dd3714265b4db54a3c390e880ab658fec5f7db895fae2046b5bb6"
+checksum = "d56e28588da92eee5c3201a6eff33fabdd49b62269c8938d4ff050ce4d900deb"
dependencies = [
"displaydoc",
"litemap",
@@ -2559,9 +3155,9 @@ dependencies = [
[[package]]
name = "icu_normalizer"
-version = "2.1.1"
+version = "2.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5f6c8828b67bf8908d82127b2054ea1b4427ff0230ee9141c54251934ab1b599"
+checksum = "12f9cf5f235641ed274641dd81c3f28d870e276763d0797aeeab72317b1c646f"
dependencies = [
"icu_collections",
"icu_normalizer_data",
@@ -2573,16 +3169,17 @@ dependencies = [
[[package]]
name = "icu_normalizer_data"
-version = "2.1.1"
+version = "2.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7aedcccd01fc5fe81e6b489c15b247b8b0690feb23304303a9e560f37efc560a"
+checksum = "1563da1ed3e0b3bf3d74c9b85917ac9c56464d2f57242270c09c9e752f8021a0"
[[package]]
name = "icu_properties"
-version = "2.1.1"
+version = "2.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e93fcd3157766c0c8da2f8cff6ce651a31f0810eaa1c51ec363ef790bbb5fb99"
+checksum = "7e7ca276ad3145661a65914e6daf131ca5120cd3dcee8f8f3214b8875184a148"
dependencies = [
+ "displaydoc",
"icu_collections",
"icu_locale_core",
"icu_properties_data",
@@ -2593,15 +3190,15 @@ dependencies = [
[[package]]
name = "icu_properties_data"
-version = "2.1.1"
+version = "2.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "02845b3647bb045f1100ecd6480ff52f34c35f82d9880e029d329c21d1054899"
+checksum = "e590f038c1464a96894fd6d10127e90a8be4509f56ff7ecef851b15cee0b7caa"
[[package]]
name = "icu_provider"
-version = "2.1.1"
+version = "2.3.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "85962cf0ce02e1e0a629cc34e7ca3e373ce20dda4c4d7294bbd0bf1fdb59e614"
+checksum = "d27bbb9d3abbefac45d55f647c9de1d44aafcd1186eb91879afef17c396c3e73"
dependencies = [
"displaydoc",
"icu_locale_core",
@@ -2631,9 +3228,9 @@ dependencies = [
[[package]]
name = "idna_adapter"
-version = "1.2.1"
+version = "1.2.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3acae9609540aa318d1bc588455225fb2085b9ed0c4f6bd0d9d5bcd86f1a0344"
+checksum = "cb68373c0d6620ef8105e855e7745e18b0d00d3bdb07fb532e434244cdb9a714"
dependencies = [
"icu_normalizer",
"icu_properties",
@@ -2694,21 +3291,23 @@ dependencies = [
]
[[package]]
-name = "ipnet"
-version = "2.11.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "469fb0b9cefa57e3ef31275ee7cacb78f2fdca44e4765491884a2b119d4eb130"
-
-[[package]]
-name = "iri-string"
-version = "0.7.9"
+name = "insta"
+version = "1.47.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4f867b9d1d896b67beb18518eda36fdb77a32ea590de864f1325b294a6d14397"
+checksum = "7b4a6248eb93a4401ed2f37dfe8ea592d3cf05b7cf4f8efa867b6895af7e094e"
dependencies = [
- "memchr",
+ "once_cell",
"serde",
+ "similar",
+ "tempfile",
]
+[[package]]
+name = "ipnet"
+version = "2.12.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "791930b43c0d5973160d90a8f3894509f2b273430f5c5c73b668636d0287c5c0"
+
[[package]]
name = "is-terminal"
version = "0.4.16"
@@ -2736,37 +3335,101 @@ dependencies = [
]
[[package]]
-name = "itertools"
-version = "0.12.1"
+name = "itertools"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ba291022dbbd398a455acf126c1e341954079855bc60dfdda641363bd6922569"
+dependencies = [
+ "either",
+]
+
+[[package]]
+name = "itertools"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "413ee7dfc52ee1a4949ceeb7dbc8a33f2d6c088194d9f922fb8318faf1f01186"
+dependencies = [
+ "either",
+]
+
+[[package]]
+name = "itertools"
+version = "0.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2b192c782037fadd9cfa75548310488aabdbf3d2da73885b31bd0abd03351285"
+dependencies = [
+ "either",
+]
+
+[[package]]
+name = "itoa"
+version = "1.0.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4a5f13b858c8d314ee3e8f639011f7ccefe71f97f96e50151fb991f267928e2c"
+
+[[package]]
+name = "jiff"
+version = "0.2.37"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0ab1baf72f08796de0260609515130699b890ac25f30e610ad894bc5856cafdb"
+dependencies = [
+ "defmt",
+ "jiff-core",
+ "jiff-static",
+ "jiff-tzdb-platform",
+ "log",
+ "portable-atomic",
+ "portable-atomic-util",
+ "serde_core",
+ "windows-link 0.2.1",
+]
+
+[[package]]
+name = "jiff-core"
+version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ba291022dbbd398a455acf126c1e341954079855bc60dfdda641363bd6922569"
+checksum = "5e52fe76043ccecc9005d2305ebaadf7d7fc0cc89ca6baa10a94d6bc68c7128c"
dependencies = [
- "either",
+ "defmt",
+ "log",
]
[[package]]
-name = "itertools"
-version = "0.13.0"
+name = "jiff-static"
+version = "0.2.37"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "413ee7dfc52ee1a4949ceeb7dbc8a33f2d6c088194d9f922fb8318faf1f01186"
+checksum = "378268a1116ad67ae6228701118ac9f491d78fda38a40a1f1a9e1348de6f7212"
dependencies = [
- "either",
+ "jiff-core",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.104",
]
[[package]]
-name = "itertools"
-version = "0.14.0"
+name = "jiff-tzdb"
+version = "0.1.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2b192c782037fadd9cfa75548310488aabdbf3d2da73885b31bd0abd03351285"
+checksum = "142bd39932ad231f10513df9ab62661fead8719872150b7ad02a2df79f4e141e"
+
+[[package]]
+name = "jiff-tzdb-platform"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "875a5a69ac2bab1a891711cf5eccbec1ce0341ea805560dcd90b7a2e925132e8"
dependencies = [
- "either",
+ "jiff-tzdb",
]
[[package]]
-name = "itoa"
-version = "1.0.15"
+name = "jobserver"
+version = "0.1.35"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4a5f13b858c8d314ee3e8f639011f7ccefe71f97f96e50151fb991f267928e2c"
+checksum = "1c00acbd29eabad4a2392fa0e921c874934dbbf4194312ad20f04a0ed67a3cb3"
+dependencies = [
+ "getrandom 0.4.3",
+ "libc",
+]
[[package]]
name = "js-sys"
@@ -2860,7 +3523,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e79019718125edc905a079a70cfa5f3820bc76139fc91d6f9abc27ea2a887139"
dependencies = [
"arrayref",
- "base64",
+ "base64 0.22.1",
"digest 0.9.0",
"libsecp256k1-core",
"libsecp256k1-gen-ecmult",
@@ -2907,9 +3570,9 @@ checksum = "cd945864f07fe9f5371a27ad7b52a172b4b499999f1d97574c9fa68373937e12"
[[package]]
name = "litemap"
-version = "0.8.1"
+version = "0.8.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6373607a59f0be73a39b6fe456b8192fcc3585f602af20751600e974dd455e77"
+checksum = "47d9d19d1d6efa0109d2f65ff4c85cddd50bd572e5a00127ab10987290bcefae"
[[package]]
name = "lock_api"
@@ -2935,11 +3598,20 @@ dependencies = [
"hashbrown 0.15.4",
]
+[[package]]
+name = "lru"
+version = "0.16.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f66e8d5d03f609abc3a39e6f08e4164ebf1447a732906d39eb9b99b7919ef39"
+dependencies = [
+ "hashbrown 0.16.1",
+]
+
[[package]]
name = "macro-string"
-version = "0.1.4"
+version = "0.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1b27834086c65ec3f9387b096d66e99f221cf081c2b738042aa252bcd41204e3"
+checksum = "59a9dbbfc75d2688ed057456ce8a3ee3f48d12eec09229f560f3643b9f275653"
dependencies = [
"proc-macro2",
"quote",
@@ -2958,66 +3630,130 @@ dependencies = [
[[package]]
name = "mega-evm"
version = "1.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5a4ced1e43118907936957ffd224fdcef42ec2d2abfc5f4e417361af1fd011ef"
dependencies = [
- "alloy-consensus",
- "alloy-eips",
- "alloy-evm",
- "alloy-hardforks",
- "alloy-op-evm",
- "alloy-op-hardforks",
+ "alloy-consensus 1.1.0",
+ "alloy-eips 1.8.3",
+ "alloy-evm 0.15.0",
+ "alloy-hardforks 0.2.13",
+ "alloy-op-evm 0.15.0",
+ "alloy-op-hardforks 0.2.13",
"alloy-primitives",
"alloy-sol-types",
"auto_impl",
- "bitflags",
- "codspeed-criterion-compat",
+ "bitflags 2.11.1",
"delegate",
"derive_more",
- "hex",
- "mega-evm",
- "mega-system-contracts",
+ "mega-system-contracts 1.7.1",
"once_cell",
- "op-alloy-consensus",
+ "op-alloy-consensus 0.18.14",
"op-alloy-flz",
- "op-revm 20.0.0",
"op-revm 8.1.0",
- "rand 0.10.2",
"revm 27.1.0",
- "revm 38.0.0",
- "revm-inspectors",
"serde",
- "serde_json",
- "sha2 0.10.9",
"thiserror",
"tracing",
]
+[[package]]
+name = "mega-evm"
+version = "2.0.0-alpha.1"
+dependencies = [
+ "alloy-consensus 2.1.1",
+ "alloy-eips 2.1.1",
+ "alloy-evm 0.36.0",
+ "alloy-hardforks 0.4.8",
+ "alloy-op-evm 0.32.0",
+ "alloy-op-hardforks 0.5.0",
+ "alloy-primitives",
+ "alloy-rpc-types-trace 2.1.1",
+ "alloy-sol-types",
+ "alloy-trie",
+ "auto_impl",
+ "codspeed-criterion-compat",
+ "delegate",
+ "derive_more",
+ "insta",
+ "mega-evm 2.0.0-alpha.1",
+ "mega-system-contracts 2.0.0-alpha.1",
+ "op-alloy-consensus 2.0.0",
+ "op-revm 20.0.0",
+ "proptest",
+ "revm 40.0.3",
+ "revm-inspectors 0.40.4",
+ "serde",
+ "serde_json",
+]
+
[[package]]
name = "mega-evme"
version = "1.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d04688d5d68411127148df8b35d64469a3056a1c38c30705c80e8a1c067d7eae"
+dependencies = [
+ "alloy-consensus 1.1.0",
+ "alloy-eips 1.8.3",
+ "alloy-json-rpc 1.1.2",
+ "alloy-network 1.1.0",
+ "alloy-primitives",
+ "alloy-provider 1.1.0",
+ "alloy-rpc-client 1.1.2",
+ "alloy-rpc-types-eth 1.1.0",
+ "alloy-rpc-types-trace 1.0.24",
+ "alloy-serde 1.8.3",
+ "alloy-sol-types",
+ "alloy-transport 1.1.2",
+ "alloy-transport-http 1.1.2",
+ "clap",
+ "dirs",
+ "mega-evm 1.7.1",
+ "mega-state-test 1.7.1",
+ "op-alloy-consensus 0.18.14",
+ "op-alloy-network 0.18.14",
+ "op-alloy-rpc-types 0.18.14",
+ "reqwest 0.12.24",
+ "revm-inspectors 0.27.3",
+ "serde",
+ "serde_json",
+ "tempfile",
+ "thiserror",
+ "tokio",
+ "tower",
+ "tracing",
+ "tracing-subscriber 0.3.20",
+]
+
+[[package]]
+name = "mega-evme"
+version = "2.0.0-alpha.1"
dependencies = [
- "alloy-consensus",
- "alloy-eips",
- "alloy-json-rpc",
- "alloy-network",
+ "alloy-consensus 2.1.1",
+ "alloy-eips 2.1.1",
+ "alloy-json-rpc 2.1.1",
+ "alloy-network 2.1.1",
"alloy-primitives",
- "alloy-provider",
- "alloy-rpc-client",
- "alloy-rpc-types-eth",
- "alloy-rpc-types-trace",
- "alloy-serde",
+ "alloy-provider 2.1.1",
+ "alloy-rpc-client 2.1.1",
+ "alloy-rpc-types-eth 2.1.1",
+ "alloy-rpc-types-trace 2.1.1",
+ "alloy-serde 2.1.1",
"alloy-sol-types",
- "alloy-transport",
- "alloy-transport-http",
+ "alloy-transport 2.1.1",
+ "alloy-transport-http 2.1.1",
+ "alloy-trie",
"clap",
"dirs",
- "mega-evm",
- "mega-evme",
- "mega-state-test",
- "op-alloy-consensus",
- "op-alloy-network",
- "op-alloy-rpc-types",
- "reqwest",
- "revm-inspectors",
+ "mega-evm 1.7.1",
+ "mega-evm 2.0.0-alpha.1",
+ "mega-evme 1.7.1",
+ "mega-evme 2.0.0-alpha.1",
+ "mega-state-test 1.7.1",
+ "op-alloy-consensus 2.0.0",
+ "op-alloy-network 2.0.0",
+ "op-alloy-rpc-types 2.0.0",
+ "revm 40.0.3",
+ "revm-inspectors 0.40.4",
"rstest",
"serde",
"serde_json",
@@ -3028,20 +3764,23 @@ dependencies = [
"tracing",
"tracing-subscriber 0.3.20",
"wiremock",
+ "zstd",
]
[[package]]
name = "mega-state-test"
version = "1.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6d0704469463ed0c3c0041e2aa37b3d81a39f9979b36ab497d48a9b1d8704e14"
dependencies = [
- "alloy-eips",
+ "alloy-eips 1.8.3",
"alloy-primitives",
"alloy-rlp",
- "alloy-serde",
+ "alloy-serde 1.8.3",
"hash-db",
"indicatif",
"k256",
- "mega-evm",
+ "mega-evm 1.7.1",
"plain_hasher",
"serde",
"serde_json",
@@ -3050,9 +3789,27 @@ dependencies = [
"walkdir",
]
+[[package]]
+name = "mega-state-test"
+version = "2.0.0-alpha.1"
+dependencies = [
+ "alloy-eips 2.1.1",
+ "alloy-rlp",
+ "alloy-trie",
+ "mega-evm 2.0.0-alpha.1",
+ "revm 40.0.3",
+ "serde",
+ "serde_json",
+ "tempfile",
+ "thiserror",
+ "walkdir",
+]
+
[[package]]
name = "mega-system-contracts"
version = "1.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4db5b3bdbdf4673e208e1dd2d9b9563d16a50fe7f9d51536613f8ee45b208db1"
dependencies = [
"alloy-primitives",
"alloy-sol-types",
@@ -3062,18 +3819,14 @@ dependencies = [
]
[[package]]
-name = "mega-t8n"
-version = "1.7.1"
+name = "mega-system-contracts"
+version = "2.0.0-alpha.1"
dependencies = [
- "alloy-consensus",
"alloy-primitives",
- "alloy-serde",
- "clap",
- "mega-evm",
- "mega-state-test",
+ "alloy-sol-types",
+ "semver 1.0.26",
"serde",
"serde_json",
- "thiserror",
]
[[package]]
@@ -3090,15 +3843,36 @@ checksum = "6877bb514081ee2a7ff5ef9de3281f14a4dd4bceac4c09388074a6b5df8a139a"
[[package]]
name = "mio"
-version = "1.1.0"
+version = "1.2.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "69d83b0086dc8ecf3ce9ae2874b2d1290252e2a30720bea58a5c6639b0092873"
+checksum = "4b18443e9c262bfe8fa82f51666e2642c53393f7e5c27b3e1aeab922cff5b9d8"
dependencies = [
"libc",
"wasi 0.11.1+wasi-snapshot-preview1",
"windows-sys 0.61.2",
]
+[[package]]
+name = "modular-bitfield"
+version = "0.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2956e537fc68236d2aa048f55704f231cc93f1c4de42fe1ecb5bd7938061fc4a"
+dependencies = [
+ "modular-bitfield-impl",
+ "static_assertions",
+]
+
+[[package]]
+name = "modular-bitfield-impl"
+version = "0.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "59b43b4fd69e3437618106f7754f34021b831a514f9e1a98ae863cabcd8d8dad"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.104",
+]
+
[[package]]
name = "native-tls"
version = "0.2.14"
@@ -3122,19 +3896,28 @@ version = "0.31.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "cf20d2fde8ff38632c426f1165ed7436270b44f199fc55284c38276f9db47c3d"
dependencies = [
- "bitflags",
+ "bitflags 2.11.1",
"cfg-if",
"cfg_aliases",
"libc",
]
+[[package]]
+name = "nonmax"
+version = "0.5.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "610a5acd306ec67f907abe5567859a3c693fb9886eb1f012ab8f2a47bef3db51"
+dependencies = [
+ "serde",
+]
+
[[package]]
name = "nu-ansi-term"
version = "0.50.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7957b9740744892f114936ab4a57b3f487491bbeafaf8083688b16841a4240e5"
dependencies = [
- "windows-sys 0.61.2",
+ "windows-sys 0.59.0",
]
[[package]]
@@ -3285,6 +4068,10 @@ name = "once_cell"
version = "1.21.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d"
+dependencies = [
+ "critical-section",
+ "portable-atomic",
+]
[[package]]
name = "once_cell_polyfill"
@@ -3298,21 +4085,54 @@ version = "11.1.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d6790f58c7ff633d8771f42965289203411a5e5c68388703c06e14f24770b41e"
+[[package]]
+name = "op-alloy"
+version = "2.0.0"
+source = "git+https://github.com/ethereum-optimism/optimism?rev=f67d87cd5c9992b62d215c043917b94e3f019629#f67d87cd5c9992b62d215c043917b94e3f019629"
+dependencies = [
+ "op-alloy-consensus 2.0.0",
+ "op-alloy-network 2.0.0",
+ "op-alloy-provider",
+ "op-alloy-rpc-types 2.0.0",
+ "op-alloy-rpc-types-engine",
+]
+
[[package]]
name = "op-alloy-consensus"
version = "0.18.14"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0c88d2940558fd69f8f07b3cbd7bb3c02fc7d31159c1a7ba9deede50e7881024"
dependencies = [
- "alloy-consensus",
- "alloy-eips",
- "alloy-network",
+ "alloy-consensus 1.1.0",
+ "alloy-eips 1.8.3",
+ "alloy-network 1.1.0",
+ "alloy-primitives",
+ "alloy-rlp",
+ "alloy-rpc-types-eth 1.1.0",
+ "alloy-serde 1.8.3",
+ "derive_more",
+ "serde",
+ "thiserror",
+]
+
+[[package]]
+name = "op-alloy-consensus"
+version = "2.0.0"
+source = "git+https://github.com/ethereum-optimism/optimism?rev=f67d87cd5c9992b62d215c043917b94e3f019629#f67d87cd5c9992b62d215c043917b94e3f019629"
+dependencies = [
+ "alloy-consensus 2.1.1",
+ "alloy-eips 2.1.1",
+ "alloy-network 2.1.1",
"alloy-primitives",
"alloy-rlp",
- "alloy-rpc-types-eth",
- "alloy-serde",
+ "alloy-rpc-types-eth 2.1.1",
+ "alloy-serde 2.1.1",
+ "bytes",
"derive_more",
+ "reth-codecs",
+ "reth-zstd-compressors",
"serde",
+ "serde_with",
"thiserror",
]
@@ -3328,14 +4148,41 @@ version = "0.18.14"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7071d7c3457d02aa0d35799cb8fbd93eabd51a21d100dcf411f4fcab6fdd2ea5"
dependencies = [
- "alloy-consensus",
- "alloy-network",
+ "alloy-consensus 1.1.0",
+ "alloy-network 1.1.0",
+ "alloy-primitives",
+ "alloy-provider 1.1.0",
+ "alloy-rpc-types-eth 1.1.0",
+ "alloy-signer 1.1.2",
+ "op-alloy-consensus 0.18.14",
+ "op-alloy-rpc-types 0.18.14",
+]
+
+[[package]]
+name = "op-alloy-network"
+version = "2.0.0"
+source = "git+https://github.com/ethereum-optimism/optimism?rev=f67d87cd5c9992b62d215c043917b94e3f019629#f67d87cd5c9992b62d215c043917b94e3f019629"
+dependencies = [
+ "alloy-consensus 2.1.1",
+ "alloy-network 2.1.1",
+ "alloy-provider 2.1.1",
+ "alloy-rpc-types-eth 2.1.1",
+ "op-alloy-consensus 2.0.0",
+ "op-alloy-rpc-types 2.0.0",
+]
+
+[[package]]
+name = "op-alloy-provider"
+version = "2.0.0"
+source = "git+https://github.com/ethereum-optimism/optimism?rev=f67d87cd5c9992b62d215c043917b94e3f019629#f67d87cd5c9992b62d215c043917b94e3f019629"
+dependencies = [
+ "alloy-network 2.1.1",
"alloy-primitives",
- "alloy-provider",
- "alloy-rpc-types-eth",
- "alloy-signer",
- "op-alloy-consensus",
- "op-alloy-rpc-types",
+ "alloy-provider 2.1.1",
+ "alloy-rpc-types-engine",
+ "alloy-transport 2.1.1",
+ "async-trait",
+ "op-alloy-rpc-types-engine",
]
[[package]]
@@ -3344,19 +4191,59 @@ version = "0.18.14"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f22201e53e8cbb67a053e88b534b4e7f02265c5406994bf35978482a9ad0ae26"
dependencies = [
- "alloy-consensus",
- "alloy-eips",
- "alloy-network-primitives",
+ "alloy-consensus 1.1.0",
+ "alloy-eips 1.8.3",
+ "alloy-network-primitives 1.1.0",
+ "alloy-primitives",
+ "alloy-rpc-types-eth 1.1.0",
+ "alloy-serde 1.8.3",
+ "derive_more",
+ "op-alloy-consensus 0.18.14",
+ "serde",
+ "serde_json",
+ "thiserror",
+]
+
+[[package]]
+name = "op-alloy-rpc-types"
+version = "2.0.0"
+source = "git+https://github.com/ethereum-optimism/optimism?rev=f67d87cd5c9992b62d215c043917b94e3f019629#f67d87cd5c9992b62d215c043917b94e3f019629"
+dependencies = [
+ "alloy-consensus 2.1.1",
+ "alloy-eips 2.1.1",
+ "alloy-network 2.1.1",
+ "alloy-network-primitives 2.1.1",
"alloy-primitives",
- "alloy-rpc-types-eth",
- "alloy-serde",
+ "alloy-rpc-types-eth 2.1.1",
+ "alloy-serde 2.1.1",
"derive_more",
- "op-alloy-consensus",
+ "op-alloy-consensus 2.0.0",
+ "reth-rpc-traits",
"serde",
"serde_json",
"thiserror",
]
+[[package]]
+name = "op-alloy-rpc-types-engine"
+version = "2.0.0"
+source = "git+https://github.com/ethereum-optimism/optimism?rev=f67d87cd5c9992b62d215c043917b94e3f019629#f67d87cd5c9992b62d215c043917b94e3f019629"
+dependencies = [
+ "alloy-consensus 2.1.1",
+ "alloy-eips 2.1.1",
+ "alloy-primitives",
+ "alloy-rlp",
+ "alloy-rpc-types-engine",
+ "alloy-serde 2.1.1",
+ "ethereum_ssz",
+ "ethereum_ssz_derive",
+ "op-alloy-consensus 2.0.0",
+ "serde",
+ "sha2 0.10.9",
+ "snap",
+ "thiserror",
+]
+
[[package]]
name = "op-revm"
version = "8.1.0"
@@ -3372,11 +4259,10 @@ dependencies = [
[[package]]
name = "op-revm"
version = "20.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a5cfe618e3426e7a65b74f105aa706cfc92cd100ade8a6588a15c6ac3002e467"
+source = "git+https://github.com/megaeth-labs/op-revm?rev=2ecb7dceed1c458a2b59ca4d8993a073968cb111#2ecb7dceed1c458a2b59ca4d8993a073968cb111"
dependencies = [
"auto_impl",
- "revm 38.0.0",
+ "revm 40.0.3",
"serde",
]
@@ -3392,7 +4278,7 @@ version = "0.10.81"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "77823a27f0babb03091cb9ed9ef80af3b39dbc82f97e8fa530374b7dafd87a45"
dependencies = [
- "bitflags",
+ "bitflags 2.11.1",
"cfg-if",
"foreign-types",
"libc",
@@ -3577,6 +4463,7 @@ dependencies = [
"arrayvec",
"bitvec",
"byte-slice-cast",
+ "bytes",
"const_format",
"impl-trait-for-tuples",
"parity-scale-codec-derive",
@@ -3664,6 +4551,15 @@ dependencies = [
"serde",
]
+[[package]]
+name = "phf"
+version = "0.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "010378780309880b08997fae13be7834dba947d36393bd372f2b1556deb2a2f6"
+dependencies = [
+ "phf_shared 0.14.0",
+]
+
[[package]]
name = "phf_generator"
version = "0.11.3"
@@ -3728,20 +4624,29 @@ dependencies = [
"siphasher",
]
+[[package]]
+name = "phf_shared"
+version = "0.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c6fd9027e2d9319be6349febd1db4e8d02aa544921200c9b777720ac34a3aa89"
+dependencies = [
+ "siphasher",
+]
+
[[package]]
name = "pin-project"
-version = "1.1.10"
+version = "1.1.13"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "677f1add503faace112b9f1373e43e9e054bfdd22ff1a63c1bc485eaec6a6a8a"
+checksum = "2466b2336ed02bcdca6b294417127b90ec92038d1d5c4fbeac971a922e0e0924"
dependencies = [
"pin-project-internal",
]
[[package]]
name = "pin-project-internal"
-version = "1.1.10"
+version = "1.1.13"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6e918e4ff8c4549eb882f14b3a4bc8c8bc93de829416eacf579f1207a8fbf861"
+checksum = "c96395f0a926bc13b1c17622aaddda1ecb55d49c8f1bf9777e4d877800a43f8b"
dependencies = [
"proc-macro2",
"quote",
@@ -3772,9 +4677,9 @@ dependencies = [
[[package]]
name = "pkg-config"
-version = "0.3.32"
+version = "0.3.34"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7edddbd0b52d732b21ad9a5fab5c704c14cd949e5e9a1ec5929a24fded1b904c"
+checksum = "f6b464fbc74e149a392436b17d523f769e057cb6877f6a5c4618bc6f11800548"
[[package]]
name = "plain_hasher"
@@ -3815,15 +4720,24 @@ dependencies = [
[[package]]
name = "portable-atomic"
-version = "1.11.1"
+version = "1.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "05c8b63e8d9609db387f0324918f81d68fe27748f084ef092fb35954d0539a85"
+
+[[package]]
+name = "portable-atomic-util"
+version = "0.2.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f84267b20a16ea918e43c6a88433c2d54fa145c92a811b5b047ccbe153674483"
+checksum = "10ab3eb7f3becc3a1cbc4f2c6f20267996cfc1a6467a873763411b136a122715"
+dependencies = [
+ "portable-atomic",
+]
[[package]]
name = "potential_utf"
-version = "0.1.4"
+version = "0.1.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b73949432f5e2a09657003c25bca5e19a0e9c84f8058ca374f49e0ebe605af77"
+checksum = "d83eb9bc6d8e5cf568e7a1101d60ee05e81ed50ea106026f3d18deeb046d7661"
dependencies = [
"zerovec",
]
@@ -3911,7 +4825,7 @@ checksum = "6fcdab19deb5195a31cf7726a210015ff1496ba1464fd42cb4f537b8b01b471f"
dependencies = [
"bit-set",
"bit-vec",
- "bitflags",
+ "bitflags 2.11.1",
"lazy_static",
"num-traits",
"rand 0.9.4",
@@ -3931,9 +4845,9 @@ checksum = "a1d01941d82fa2ab50be1e79e6714289dd7cde78eba4c074bc5a4374f650dfe0"
[[package]]
name = "quote"
-version = "1.0.40"
+version = "1.0.47"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1885c039570dc00dcb4ff087a89e185fd56bae234ddc7f056a945bf36467248d"
+checksum = "1fbf4db142a473a8d80c26bbf18454ed458bf8d26c8219c331daecfdbd079001"
dependencies = [
"proc-macro2",
]
@@ -3979,17 +4893,6 @@ dependencies = [
"serde",
]
-[[package]]
-name = "rand"
-version = "0.10.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c7f5fa3a058cd35567ef9bfa5e75732bee0f9e4c55fa90477bef2dfcdbc4be80"
-dependencies = [
- "chacha20",
- "getrandom 0.4.3",
- "rand_core 0.10.1",
-]
-
[[package]]
name = "rand_chacha"
version = "0.3.1"
@@ -4029,12 +4932,6 @@ dependencies = [
"serde",
]
-[[package]]
-name = "rand_core"
-version = "0.10.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "63b8176103e19a2643978565ca18b50549f6101881c443590420e4dc998a3c69"
-
[[package]]
name = "rand_xorshift"
version = "0.4.0"
@@ -4059,7 +4956,7 @@ version = "0.5.18"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ed2bf2547551a7053d6fdfafda3f938979645c44812fbfcda098faae3f1a362d"
dependencies = [
- "bitflags",
+ "bitflags 2.11.1",
]
[[package]]
@@ -4134,31 +5031,62 @@ version = "0.12.24"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9d0946410b9f7b082a427e4ef5c8ff541a88b357bc6c637c40db3a68ac70a36f"
dependencies = [
- "base64",
+ "base64 0.22.1",
"bytes",
"encoding_rs",
"futures-core",
- "h2",
+ "h2",
+ "http",
+ "http-body",
+ "http-body-util",
+ "hyper",
+ "hyper-rustls",
+ "hyper-tls",
+ "hyper-util",
+ "js-sys",
+ "log",
+ "mime",
+ "native-tls",
+ "percent-encoding",
+ "pin-project-lite",
+ "rustls-pki-types",
+ "serde",
+ "serde_json",
+ "serde_urlencoded",
+ "sync_wrapper",
+ "tokio",
+ "tokio-native-tls",
+ "tower",
+ "tower-http",
+ "tower-service",
+ "url",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
+ "web-sys",
+]
+
+[[package]]
+name = "reqwest"
+version = "0.13.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "16a1cfa75cc186dd73d5818e510e042e40927bccc9c236b061cea97e1eb08029"
+dependencies = [
+ "base64 0.23.1",
+ "bytes",
+ "futures-core",
"http",
"http-body",
"http-body-util",
"hyper",
- "hyper-rustls",
- "hyper-tls",
"hyper-util",
"js-sys",
"log",
- "mime",
- "native-tls",
"percent-encoding",
"pin-project-lite",
- "rustls-pki-types",
"serde",
"serde_json",
- "serde_urlencoded",
"sync_wrapper",
"tokio",
- "tokio-native-tls",
"tower",
"tower-http",
"tower-service",
@@ -4168,6 +5096,84 @@ dependencies = [
"web-sys",
]
+[[package]]
+name = "reth-codecs"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f9c37bb4d1bac98661bf9128e1141b969034640d68697b22f70377e492fd332c"
+dependencies = [
+ "alloy-consensus 2.1.1",
+ "alloy-eips 2.1.1",
+ "alloy-genesis",
+ "alloy-primitives",
+ "alloy-trie",
+ "bytes",
+ "modular-bitfield",
+ "parity-scale-codec",
+ "reth-codecs-derive",
+ "reth-zstd-compressors",
+ "serde",
+]
+
+[[package]]
+name = "reth-codecs-derive"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ceeb8dab90194305d3f7e3f043a22d2db1fb54b6dcf5d8e75c5a4fa8540e1f57"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.104",
+]
+
+[[package]]
+name = "reth-primitives-traits"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9102518f0bbf99bc8f0e656a56fb2a7513248630275b608d3706076a82fde42b"
+dependencies = [
+ "alloy-consensus 2.1.1",
+ "alloy-eips 2.1.1",
+ "alloy-genesis",
+ "alloy-primitives",
+ "alloy-rlp",
+ "alloy-rpc-types-eth 2.1.1",
+ "alloy-trie",
+ "bytes",
+ "derive_more",
+ "once_cell",
+ "revm-bytecode 11.0.1",
+ "revm-primitives 24.0.1",
+ "revm-state 12.0.1",
+ "secp256k1 0.30.0",
+ "serde",
+ "thiserror",
+]
+
+[[package]]
+name = "reth-rpc-traits"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9fa03a2c9681c385ae1c72b169ac9c3525163b71db0b3362f16e8929e19e45fd"
+dependencies = [
+ "alloy-consensus 2.1.1",
+ "alloy-network 2.1.1",
+ "alloy-primitives",
+ "alloy-rpc-types-eth 2.1.1",
+ "alloy-signer 2.1.1",
+ "reth-primitives-traits",
+ "thiserror",
+]
+
+[[package]]
+name = "reth-zstd-compressors"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc0e86cf594718932d42cebce1fa48292fb7b92721f7c914631add1ca970e814"
+dependencies = [
+ "zstd",
+]
+
[[package]]
name = "revm"
version = "27.1.0"
@@ -4189,21 +5195,21 @@ dependencies = [
[[package]]
name = "revm"
-version = "38.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "91202d39dbe8e8d10e9e8f2b76c30da68ecd1d25be69ba6d853ad0d03a3a398a"
+version = "40.0.3"
+source = "git+https://github.com/megaeth-labs/revm?rev=fd230a3427d1b96c88e0b581bab8a7763c8ec298#fd230a3427d1b96c88e0b581bab8a7763c8ec298"
dependencies = [
- "revm-bytecode 10.0.0",
- "revm-context 16.0.1",
- "revm-context-interface 17.0.1",
- "revm-database 13.0.1",
- "revm-database-interface 11.0.1",
- "revm-handler 18.1.0",
- "revm-inspector 19.0.0",
- "revm-interpreter 35.0.1",
- "revm-precompile 34.0.0",
- "revm-primitives 23.0.0",
- "revm-state 11.0.1",
+ "revm-bytecode 11.0.1",
+ "revm-context 18.0.3",
+ "revm-context-interface 19.0.3",
+ "revm-database 15.0.2",
+ "revm-database-interface 12.1.1",
+ "revm-handler 20.0.3",
+ "revm-inspector 21.0.3",
+ "revm-interpreter 37.0.3",
+ "revm-precompile 36.0.3",
+ "revm-primitives 24.0.1",
+ "revm-state 12.0.1",
+ "revm-statetest-types",
]
[[package]]
@@ -4220,13 +5226,12 @@ dependencies = [
[[package]]
name = "revm-bytecode"
-version = "10.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bdbb3a3d735efa94c91f2ef6bf20a35f99a77bc78f3e25bd758336901bdf9661"
+version = "11.0.1"
+source = "git+https://github.com/megaeth-labs/revm?rev=fd230a3427d1b96c88e0b581bab8a7763c8ec298#fd230a3427d1b96c88e0b581bab8a7763c8ec298"
dependencies = [
"bitvec",
"phf 0.13.1",
- "revm-primitives 23.0.0",
+ "revm-primitives 24.0.1",
"serde",
]
@@ -4248,18 +5253,17 @@ dependencies = [
[[package]]
name = "revm-context"
-version = "16.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c5f68d928d8b228e0faeb1c6ed75c4fde7d124f1ddf9119b67e7a0ad4041237d"
+version = "18.0.3"
+source = "git+https://github.com/megaeth-labs/revm?rev=fd230a3427d1b96c88e0b581bab8a7763c8ec298#fd230a3427d1b96c88e0b581bab8a7763c8ec298"
dependencies = [
"bitvec",
"cfg-if",
"derive-where",
- "revm-bytecode 10.0.0",
- "revm-context-interface 17.0.1",
- "revm-database-interface 11.0.1",
- "revm-primitives 23.0.0",
- "revm-state 11.0.1",
+ "revm-bytecode 11.0.1",
+ "revm-context-interface 19.0.3",
+ "revm-database-interface 12.1.1",
+ "revm-primitives 24.0.1",
+ "revm-state 12.0.1",
"serde",
]
@@ -4281,17 +5285,16 @@ dependencies = [
[[package]]
name = "revm-context-interface"
-version = "17.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1f3758e6167c4ba7a59a689c519a047edaefcd4c37d74f279b93ed87bc8aece4"
+version = "19.0.3"
+source = "git+https://github.com/megaeth-labs/revm?rev=fd230a3427d1b96c88e0b581bab8a7763c8ec298#fd230a3427d1b96c88e0b581bab8a7763c8ec298"
dependencies = [
"alloy-eip2930",
"alloy-eip7702",
"auto_impl",
"either",
- "revm-database-interface 11.0.1",
- "revm-primitives 23.0.0",
- "revm-state 11.0.1",
+ "revm-database-interface 12.1.1",
+ "revm-primitives 24.0.1",
+ "revm-state 12.0.1",
"serde",
]
@@ -4301,9 +5304,9 @@ version = "7.0.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "40000c7d917c865f6c232a78581b78e70c43f52db17282bd1b52d4f0565bc8a2"
dependencies = [
- "alloy-eips",
- "alloy-provider",
- "alloy-transport",
+ "alloy-eips 1.8.3",
+ "alloy-provider 1.1.0",
+ "alloy-transport 1.1.2",
"revm-bytecode 6.2.1",
"revm-database-interface 7.0.4",
"revm-primitives 20.2.1",
@@ -4314,16 +5317,19 @@ dependencies = [
[[package]]
name = "revm-database"
-version = "13.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c281a1f11d3bcb8c0bba1199ed6bcb001d1aeb3d4fb366819e14f88723989a4e"
+version = "15.0.2"
+source = "git+https://github.com/megaeth-labs/revm?rev=fd230a3427d1b96c88e0b581bab8a7763c8ec298#fd230a3427d1b96c88e0b581bab8a7763c8ec298"
dependencies = [
- "alloy-eips",
- "revm-bytecode 10.0.0",
- "revm-database-interface 11.0.1",
- "revm-primitives 23.0.0",
- "revm-state 11.0.1",
+ "alloy-eips 2.1.1",
+ "alloy-provider 2.1.1",
+ "alloy-transport 2.1.1",
+ "derive_more",
+ "revm-bytecode 11.0.1",
+ "revm-database-interface 12.1.1",
+ "revm-primitives 24.0.1",
+ "revm-state 12.0.1",
"serde",
+ "tokio",
]
[[package]]
@@ -4342,16 +5348,16 @@ dependencies = [
[[package]]
name = "revm-database-interface"
-version = "11.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d89efb9832a4e3742bb4ded5f7fe5bf905e8860e69427d4dfec153484fc6d304"
+version = "12.1.1"
+source = "git+https://github.com/megaeth-labs/revm?rev=fd230a3427d1b96c88e0b581bab8a7763c8ec298#fd230a3427d1b96c88e0b581bab8a7763c8ec298"
dependencies = [
"auto_impl",
"either",
- "revm-primitives 23.0.0",
- "revm-state 11.0.1",
+ "revm-primitives 24.0.1",
+ "revm-state 12.0.1",
"serde",
"thiserror",
+ "tokio",
]
[[package]]
@@ -4375,20 +5381,19 @@ dependencies = [
[[package]]
name = "revm-handler"
-version = "18.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "783e903d6922b7f5f9a940d1bb229530502d2924b1aed9d5ca5a94ebf065d460"
+version = "20.0.3"
+source = "git+https://github.com/megaeth-labs/revm?rev=fd230a3427d1b96c88e0b581bab8a7763c8ec298#fd230a3427d1b96c88e0b581bab8a7763c8ec298"
dependencies = [
"auto_impl",
"derive-where",
- "revm-bytecode 10.0.0",
- "revm-context 16.0.1",
- "revm-context-interface 17.0.1",
- "revm-database-interface 11.0.1",
- "revm-interpreter 35.0.1",
- "revm-precompile 34.0.0",
- "revm-primitives 23.0.0",
- "revm-state 11.0.1",
+ "revm-bytecode 11.0.1",
+ "revm-context 18.0.3",
+ "revm-context-interface 19.0.3",
+ "revm-database-interface 12.1.1",
+ "revm-interpreter 37.0.3",
+ "revm-precompile 36.0.3",
+ "revm-primitives 24.0.1",
+ "revm-state 12.0.1",
"serde",
]
@@ -4412,18 +5417,17 @@ dependencies = [
[[package]]
name = "revm-inspector"
-version = "19.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8216ad58422090d0daa9eb430e0a081f7ad07e7fd30681dee71f8420c99624e0"
+version = "21.0.3"
+source = "git+https://github.com/megaeth-labs/revm?rev=fd230a3427d1b96c88e0b581bab8a7763c8ec298#fd230a3427d1b96c88e0b581bab8a7763c8ec298"
dependencies = [
"auto_impl",
"either",
- "revm-context 16.0.1",
- "revm-database-interface 11.0.1",
- "revm-handler 18.1.0",
- "revm-interpreter 35.0.1",
- "revm-primitives 23.0.0",
- "revm-state 11.0.1",
+ "revm-context 18.0.3",
+ "revm-database-interface 12.1.1",
+ "revm-handler 20.0.3",
+ "revm-interpreter 37.0.3",
+ "revm-primitives 24.0.1",
+ "revm-state 12.0.1",
"serde",
"serde_json",
]
@@ -4435,8 +5439,8 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2483827fec2c31db4ada14e0b5523c377d1084337d1dbe135faaf14c218ab1af"
dependencies = [
"alloy-primitives",
- "alloy-rpc-types-eth",
- "alloy-rpc-types-trace",
+ "alloy-rpc-types-eth 1.1.0",
+ "alloy-rpc-types-trace 1.0.24",
"alloy-sol-types",
"anstyle",
"colorchoice",
@@ -4446,6 +5450,24 @@ dependencies = [
"thiserror",
]
+[[package]]
+name = "revm-inspectors"
+version = "0.40.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e93b96ddc470322a7294b8aecad862480625a9f1346d42fea51b1cce54afdb05"
+dependencies = [
+ "alloy-primitives",
+ "alloy-rpc-types-eth 2.1.1",
+ "alloy-rpc-types-trace 2.1.1",
+ "alloy-sol-types",
+ "anstyle",
+ "colorchoice",
+ "revm 40.0.3",
+ "serde",
+ "serde_json",
+ "thiserror",
+]
+
[[package]]
name = "revm-interpreter"
version = "24.0.0"
@@ -4460,14 +5482,13 @@ dependencies = [
[[package]]
name = "revm-interpreter"
-version = "35.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1ece9f41b69658c15d748288a4dbdfc06a63f3ce93d983af440de3f1631dce6a"
+version = "37.0.3"
+source = "git+https://github.com/megaeth-labs/revm?rev=fd230a3427d1b96c88e0b581bab8a7763c8ec298#fd230a3427d1b96c88e0b581bab8a7763c8ec298"
dependencies = [
- "revm-bytecode 10.0.0",
- "revm-context-interface 17.0.1",
- "revm-primitives 23.0.0",
- "revm-state 11.0.1",
+ "revm-bytecode 11.0.1",
+ "revm-context-interface 19.0.3",
+ "revm-primitives 24.0.1",
+ "revm-state 12.0.1",
"serde",
]
@@ -4501,9 +5522,8 @@ dependencies = [
[[package]]
name = "revm-precompile"
-version = "34.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a346a8cc6c8c39bd65306641c692191299c0a7b63d38810e39e8fe9b92378660"
+version = "36.0.3"
+source = "git+https://github.com/megaeth-labs/revm?rev=fd230a3427d1b96c88e0b581bab8a7763c8ec298#fd230a3427d1b96c88e0b581bab8a7763c8ec298"
dependencies = [
"ark-bls12-381",
"ark-bn254",
@@ -4512,12 +5532,13 @@ dependencies = [
"ark-serialize 0.5.0",
"arrayref",
"aurora-engine-modexp",
+ "blst",
"c-kzg",
"cfg-if",
"k256",
"p256",
- "revm-context-interface 17.0.1",
- "revm-primitives 23.0.0",
+ "revm-context-interface 19.0.3",
+ "revm-primitives 24.0.1",
"ripemd",
"secp256k1 0.31.1",
"sha2 0.10.9",
@@ -4537,12 +5558,10 @@ dependencies = [
[[package]]
name = "revm-primitives"
-version = "23.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0c99bda77d9661521ba0b4bc04558c6692074f01e65dd420fa3b893033d9b8a2"
+version = "24.0.1"
+source = "git+https://github.com/megaeth-labs/revm?rev=fd230a3427d1b96c88e0b581bab8a7763c8ec298#fd230a3427d1b96c88e0b581bab8a7763c8ec298"
dependencies = [
"alloy-primitives",
- "num_enum",
"once_cell",
"serde",
]
@@ -4553,7 +5572,7 @@ version = "7.0.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f9d7f39ea56df3bfbb3c81c99b1f028d26f205b6004156baffbf1a4f84b46cfa"
dependencies = [
- "bitflags",
+ "bitflags 2.11.1",
"revm-bytecode 6.2.1",
"revm-primitives 20.2.1",
"serde",
@@ -4561,15 +5580,32 @@ dependencies = [
[[package]]
name = "revm-state"
-version = "11.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c32490ed687dba31c3c882beb8c20408bdd30ef96690d8f145b0ee9a87040bfe"
+version = "12.0.1"
+source = "git+https://github.com/megaeth-labs/revm?rev=fd230a3427d1b96c88e0b581bab8a7763c8ec298#fd230a3427d1b96c88e0b581bab8a7763c8ec298"
+dependencies = [
+ "alloy-eip7928 0.4.11",
+ "bitflags 2.11.1",
+ "nonmax",
+ "revm-bytecode 11.0.1",
+ "revm-primitives 24.0.1",
+ "serde",
+]
+
+[[package]]
+name = "revm-statetest-types"
+version = "19.0.3"
+source = "git+https://github.com/megaeth-labs/revm?rev=fd230a3427d1b96c88e0b581bab8a7763c8ec298#fd230a3427d1b96c88e0b581bab8a7763c8ec298"
dependencies = [
- "alloy-eip7928",
- "bitflags",
- "revm-bytecode 10.0.0",
- "revm-primitives 23.0.0",
+ "alloy-eip7928 0.4.11",
+ "k256",
+ "revm-context 18.0.3",
+ "revm-context-interface 19.0.3",
+ "revm-database 15.0.2",
+ "revm-primitives 24.0.1",
+ "revm-state 12.0.1",
"serde",
+ "serde_json",
+ "thiserror",
]
[[package]]
@@ -4724,11 +5760,11 @@ version = "1.0.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "11181fbabf243db407ef8df94a6ce0b2f9a733bd8be4ad02b4eda9602296cac8"
dependencies = [
- "bitflags",
+ "bitflags 2.11.1",
"errno",
"libc",
"linux-raw-sys",
- "windows-sys 0.60.2",
+ "windows-sys 0.59.0",
]
[[package]]
@@ -4898,7 +5934,7 @@ version = "2.11.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "897b2245f0b511c87893af39b033e5ca9cce68824c4d7e7630b5a1d339658d02"
dependencies = [
- "bitflags",
+ "bitflags 2.11.1",
"core-foundation",
"core-foundation-sys",
"libc",
@@ -4983,15 +6019,16 @@ dependencies = [
[[package]]
name = "serde_json"
-version = "1.0.141"
+version = "1.0.151"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "30b9eff21ebe718216c6ec64e1d9ac57087aad11efc64e32002bce4a0d4c03d3"
+checksum = "c841b55ecdae098c80dcae9cf767f6f8a0c2cdb3416bbef72181df4d0fe73f14"
dependencies = [
"indexmap 2.10.0",
"itoa",
"memchr",
- "ryu",
"serde",
+ "serde_core",
+ "zmij",
]
[[package]]
@@ -5008,19 +6045,20 @@ dependencies = [
[[package]]
name = "serde_with"
-version = "3.14.1"
+version = "3.23.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c522100790450cf78eeac1507263d0a350d4d5b30df0c8e1fe051a10c22b376e"
+checksum = "935177bb8c0cd8ca1a4e6d1a2ac8988bea69cab4f9d3a31311e012ad27868ea4"
dependencies = [
- "base64",
+ "base64 0.23.1",
+ "bs58",
"chrono",
"hex",
"indexmap 1.9.3",
"indexmap 2.10.0",
+ "jiff",
"schemars 0.9.0",
"schemars 1.0.4",
- "serde",
- "serde_derive",
+ "serde_core",
"serde_json",
"serde_with_macros",
"time",
@@ -5028,14 +6066,14 @@ dependencies = [
[[package]]
name = "serde_with_macros"
-version = "3.14.1"
+version = "3.23.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "327ada00f7d64abaac1e55a6911e90cf665aa051b9a561c7006c157f4633135e"
+checksum = "1d607aa01a3cb0ad757d6fd216136910db3c97b102fe686585689615a02dbcdc"
dependencies = [
- "darling",
+ "darling 0.24.1",
"proc-macro2",
"quote",
- "syn 2.0.104",
+ "syn 3.0.6",
]
[[package]]
@@ -5117,6 +6155,12 @@ dependencies = [
"rand_core 0.6.4",
]
+[[package]]
+name = "similar"
+version = "2.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bbbb5d9659141646ae647b42fe094daf6c6192d1620870b449d9557f748b2daa"
+
[[package]]
name = "siphasher"
version = "1.0.1"
@@ -5125,9 +6169,9 @@ checksum = "56199f7ddabf13fe5074ce809e7d3f42b42ae711800501b5b16ea82ad029c39d"
[[package]]
name = "slab"
-version = "0.4.11"
+version = "0.4.12"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7a2ae44ef20feb57a68b23d846850f861394c2e02dc425a50098ae8c90267589"
+checksum = "0c790de23124f9ab44544d7ac05d60440adc586479ce501c1d6d7da3cd8c9cf5"
[[package]]
name = "smallvec"
@@ -5138,14 +6182,20 @@ dependencies = [
"serde",
]
+[[package]]
+name = "snap"
+version = "1.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "199905e6153d6405f9728fe44daace35f8f837bbf830bb6e85fbd5828709a886"
+
[[package]]
name = "socket2"
-version = "0.6.1"
+version = "0.6.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "17129e116933cf371d018bb80ae557e889637989d8638274fb25622827b03881"
+checksum = "c3d1e2c7f27f8d4cb10542a02c49005dbd6e93095799d6f3be745fae9f8fedd4"
dependencies = [
"libc",
- "windows-sys 0.60.2",
+ "windows-sys 0.61.2",
]
[[package]]
@@ -5218,12 +6268,14 @@ checksum = "6ce2be8dc25455e1f91df71bfa12ad37d7af1092ae736f3a6cd0e37bc7810596"
[[package]]
name = "state-test"
-version = "1.7.1"
+version = "2.0.0-alpha.1"
dependencies = [
+ "alloy-rlp",
"clap",
- "mega-evm",
- "mega-state-test",
+ "mega-evm 2.0.0-alpha.1",
+ "mega-state-test 2.0.0-alpha.1",
"serde_json",
+ "tempfile",
]
[[package]]
@@ -5297,11 +6349,22 @@ dependencies = [
"unicode-ident",
]
+[[package]]
+name = "syn"
+version = "3.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8593e8e72159ed2257d083c7a454a85cbf854f37a0966d8d483aff8c8a3ebcee"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
[[package]]
name = "syn-solidity"
-version = "1.4.1"
+version = "1.6.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ff790eb176cc81bb8936aed0f7b9f14fc4670069a2d371b3e3b0ecce908b2cb3"
+checksum = "ec005042c7d952febc1a3ef5b0f6674e9054aa836877a31c90b20e25b3d31744"
dependencies = [
"paste",
"proc-macro2",
@@ -5320,22 +6383,22 @@ dependencies = [
[[package]]
name = "synstructure"
-version = "0.13.2"
+version = "0.14.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "728a70f3dbaf5bab7f0c4b1ac8d7ae5ea60a4b5549c8a5914361c99147a709d2"
+checksum = "901704edd0dfe137f1987838ee4f259e4e063c31371bdb423f7ae38ec6f77f02"
dependencies = [
"proc-macro2",
"quote",
- "syn 2.0.104",
+ "syn 3.0.6",
]
[[package]]
name = "system-configuration"
-version = "0.6.1"
+version = "0.7.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3c879d448e9d986b661742763247d3693ed13609438cf3d006f51f5368a5ba6b"
+checksum = "a13f3d0daba03132c0aa9767f98351b3488edc2c100cda2d2ec2b04f3d8d3c8b"
dependencies = [
- "bitflags",
+ "bitflags 2.11.1",
"core-foundation",
"system-configuration-sys",
]
@@ -5371,22 +6434,22 @@ dependencies = [
[[package]]
name = "thiserror"
-version = "2.0.12"
+version = "2.0.20"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "567b8a2dae586314f7be2a752ec7474332959c6460e02bde30d702a66d488708"
+checksum = "ec86235f5fcc2a73650310756d2ac5b138a5780bbbdfae3eeccec992c435ba4f"
dependencies = [
"thiserror-impl",
]
[[package]]
name = "thiserror-impl"
-version = "2.0.12"
+version = "2.0.20"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7f7cf42b4507d8ea322120659672cf1b9dbb93f8f2d4ecfd6e51350ff5b17a1d"
+checksum = "bc04cd3e1236dd4a98afca4569f2deb3f120e5422a4023be2cb683f8486292af"
dependencies = [
"proc-macro2",
"quote",
- "syn 2.0.104",
+ "syn 3.0.6",
]
[[package]]
@@ -5438,20 +6501,11 @@ dependencies = [
"time-core",
]
-[[package]]
-name = "tiny-keccak"
-version = "2.0.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2c9d3793400a45f954c52e73d068316d76b6f4e36977e3fcebb13a2721e80237"
-dependencies = [
- "crunchy",
-]
-
[[package]]
name = "tinystr"
-version = "0.8.2"
+version = "0.8.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "42d3e9c45c09de15d06dd8acf5f4e0e399e85927b7f00711024eb7ae10fa4869"
+checksum = "b1e27c91459209c2986af3dcf603a5a74a4368754ce37414f59acc971167f643"
dependencies = [
"displaydoc",
"zerovec",
@@ -5467,11 +6521,17 @@ dependencies = [
"serde_json",
]
+[[package]]
+name = "tinyvec"
+version = "1.13.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fd3ca314f692efd6c868f8408f53fe444634a845f96c028b97d35f6a1f79f0ee"
+
[[package]]
name = "tokio"
-version = "1.48.0"
+version = "1.53.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ff360e02eab121e0bc37a2d3b4d4dc622e6eda3a8e5253d5435ecf5bd4c68408"
+checksum = "202caea871b69668250d242070849eb495be178ed697a3e98aebce5bc81a0bed"
dependencies = [
"bytes",
"libc",
@@ -5484,13 +6544,13 @@ dependencies = [
[[package]]
name = "tokio-macros"
-version = "2.6.0"
+version = "2.7.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "af407857209536a95c8e56f8231ef2c2e2aff839b22e07a1ffcbc617e9db9fa5"
+checksum = "78773a2a397f451582ce068015985c33193cf6dea8b74d2a639fe457b2f07b0e"
dependencies = [
"proc-macro2",
"quote",
- "syn 2.0.104",
+ "syn 3.0.6",
]
[[package]]
@@ -5515,9 +6575,9 @@ dependencies = [
[[package]]
name = "tokio-stream"
-version = "0.1.17"
+version = "0.1.19"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eca58d7bba4a75707817a2c44174253f9236b2d5fbd055602e9d5c07c139a047"
+checksum = "a3d06f0b082ba57c26b79407372e57cf2a1e28124f78e9479fe80322cf53420b"
dependencies = [
"futures-core",
"pin-project-lite",
@@ -5527,13 +6587,14 @@ dependencies = [
[[package]]
name = "tokio-util"
-version = "0.7.17"
+version = "0.7.19"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2efa149fe76073d6e8fd97ef4f4eca7b67f599660115591483572e406e165594"
+checksum = "494815d09bf52b5548659851081238f0ca39ff638363907596da739561c62c52"
dependencies = [
"bytes",
"futures-core",
"futures-sink",
+ "libc",
"pin-project-lite",
"tokio",
]
@@ -5552,14 +6613,14 @@ checksum = "41fe8c660ae4257887cf66394862d21dbca4a6ddd26f04a3560410406a2f819a"
dependencies = [
"indexmap 2.10.0",
"toml_datetime",
- "winnow",
+ "winnow 0.7.12",
]
[[package]]
name = "tower"
-version = "0.5.2"
+version = "0.5.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d039ad9159c98b70ecfd540b2573b97f7f52c3e8d9f8ad57a24b916a536975f9"
+checksum = "ebe5ef63511595f1344e2d5cfa636d973292adc0eec1f0ad45fae9f0851ab1d4"
dependencies = [
"futures-core",
"futures-util",
@@ -5572,20 +6633,20 @@ dependencies = [
[[package]]
name = "tower-http"
-version = "0.6.6"
+version = "0.6.11"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "adc82fd73de2a9722ac5da747f12383d2bfdb93591ee6c58486e0097890f05f2"
+checksum = "4cfcf7e2740e6fc6d4d688b4ef00650406bb94adf4731e43c096c3a19fe40840"
dependencies = [
- "bitflags",
+ "bitflags 2.11.1",
"bytes",
"futures-util",
"http",
"http-body",
- "iri-string",
"pin-project-lite",
"tower",
"tower-layer",
"tower-service",
+ "url",
]
[[package]]
@@ -5624,9 +6685,9 @@ dependencies = [
[[package]]
name = "tracing-core"
-version = "0.1.34"
+version = "0.1.36"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b9d12581f227e93f094d3af2ae690a574abb8a2b9b7a96e7cfe9647b2b617678"
+checksum = "db97caf9d906fbde555dd62fa95ddba9eecfd14cb388e4f491a66d74cd5fb79a"
dependencies = [
"once_cell",
"valuable",
@@ -5729,14 +6790,15 @@ checksum = "8ecb6da28b8a351d773b68d5825ac39017e680750f980f3a1a85cd8dd28a47c1"
[[package]]
name = "url"
-version = "2.5.7"
+version = "2.5.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "08bc136a29a3d1758e07a9cca267be308aeebf5cfd5a10f3f67ab2097683ef5b"
+checksum = "ff67a8a4397373c3ef660812acab3268222035010ab8680ec4215f38ba3d0eed"
dependencies = [
"form_urlencoded",
"idna",
"percent-encoding",
"serde",
+ "serde_derive",
]
[[package]]
@@ -5923,7 +6985,7 @@ version = "0.1.11"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22"
dependencies = [
- "windows-sys 0.61.2",
+ "windows-sys 0.59.0",
]
[[package]]
@@ -5935,8 +6997,8 @@ dependencies = [
"windows-implement",
"windows-interface",
"windows-link 0.1.3",
- "windows-result",
- "windows-strings",
+ "windows-result 0.3.4",
+ "windows-strings 0.4.2",
]
[[package]]
@@ -5975,13 +7037,13 @@ checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5"
[[package]]
name = "windows-registry"
-version = "0.5.3"
+version = "0.6.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5b8a9ed28765efc97bbc954883f4e6796c33a06546ebafacbabee9696967499e"
+checksum = "02752bf7fbdcce7f2a27a742f798510f3e5ad88dbe84871e5168e2120c3d5720"
dependencies = [
- "windows-link 0.1.3",
- "windows-result",
- "windows-strings",
+ "windows-link 0.2.1",
+ "windows-result 0.4.1",
+ "windows-strings 0.5.1",
]
[[package]]
@@ -5993,6 +7055,15 @@ dependencies = [
"windows-link 0.1.3",
]
+[[package]]
+name = "windows-result"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7781fa89eaf60850ac3d2da7af8e5242a5ea78d1a11c49bf2910bb5a73853eb5"
+dependencies = [
+ "windows-link 0.2.1",
+]
+
[[package]]
name = "windows-strings"
version = "0.4.2"
@@ -6003,30 +7074,30 @@ dependencies = [
]
[[package]]
-name = "windows-sys"
-version = "0.52.0"
+name = "windows-strings"
+version = "0.5.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d"
+checksum = "7837d08f69c77cf6b07689544538e017c1bfcf57e34b4c0ff58e6c2cd3b37091"
dependencies = [
- "windows-targets 0.52.6",
+ "windows-link 0.2.1",
]
[[package]]
name = "windows-sys"
-version = "0.59.0"
+version = "0.52.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b"
+checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d"
dependencies = [
- "windows-targets 0.52.6",
+ "windows-targets",
]
[[package]]
name = "windows-sys"
-version = "0.60.2"
+version = "0.59.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f2f500e4d28234f72040990ec9d39e3a6b950f9f22d3dba18416c35882612bcb"
+checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b"
dependencies = [
- "windows-targets 0.53.2",
+ "windows-targets",
]
[[package]]
@@ -6044,30 +7115,14 @@ version = "0.52.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973"
dependencies = [
- "windows_aarch64_gnullvm 0.52.6",
- "windows_aarch64_msvc 0.52.6",
- "windows_i686_gnu 0.52.6",
- "windows_i686_gnullvm 0.52.6",
- "windows_i686_msvc 0.52.6",
- "windows_x86_64_gnu 0.52.6",
- "windows_x86_64_gnullvm 0.52.6",
- "windows_x86_64_msvc 0.52.6",
-]
-
-[[package]]
-name = "windows-targets"
-version = "0.53.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c66f69fcc9ce11da9966ddb31a40968cad001c5bedeb5c2b82ede4253ab48aef"
-dependencies = [
- "windows_aarch64_gnullvm 0.53.0",
- "windows_aarch64_msvc 0.53.0",
- "windows_i686_gnu 0.53.0",
- "windows_i686_gnullvm 0.53.0",
- "windows_i686_msvc 0.53.0",
- "windows_x86_64_gnu 0.53.0",
- "windows_x86_64_gnullvm 0.53.0",
- "windows_x86_64_msvc 0.53.0",
+ "windows_aarch64_gnullvm",
+ "windows_aarch64_msvc",
+ "windows_i686_gnu",
+ "windows_i686_gnullvm",
+ "windows_i686_msvc",
+ "windows_x86_64_gnu",
+ "windows_x86_64_gnullvm",
+ "windows_x86_64_msvc",
]
[[package]]
@@ -6076,84 +7131,42 @@ version = "0.52.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3"
-[[package]]
-name = "windows_aarch64_gnullvm"
-version = "0.53.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "86b8d5f90ddd19cb4a147a5fa63ca848db3df085e25fee3cc10b39b6eebae764"
-
[[package]]
name = "windows_aarch64_msvc"
version = "0.52.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469"
-[[package]]
-name = "windows_aarch64_msvc"
-version = "0.53.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c7651a1f62a11b8cbd5e0d42526e55f2c99886c77e007179efff86c2b137e66c"
-
[[package]]
name = "windows_i686_gnu"
version = "0.52.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b"
-[[package]]
-name = "windows_i686_gnu"
-version = "0.53.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c1dc67659d35f387f5f6c479dc4e28f1d4bb90ddd1a5d3da2e5d97b42d6272c3"
-
[[package]]
name = "windows_i686_gnullvm"
version = "0.52.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66"
-[[package]]
-name = "windows_i686_gnullvm"
-version = "0.53.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9ce6ccbdedbf6d6354471319e781c0dfef054c81fbc7cf83f338a4296c0cae11"
-
[[package]]
name = "windows_i686_msvc"
version = "0.52.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66"
-[[package]]
-name = "windows_i686_msvc"
-version = "0.53.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "581fee95406bb13382d2f65cd4a908ca7b1e4c2f1917f143ba16efe98a589b5d"
-
[[package]]
name = "windows_x86_64_gnu"
version = "0.52.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78"
-[[package]]
-name = "windows_x86_64_gnu"
-version = "0.53.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2e55b5ac9ea33f2fc1716d1742db15574fd6fc8dadc51caab1c16a3d3b4190ba"
-
[[package]]
name = "windows_x86_64_gnullvm"
version = "0.52.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"
-[[package]]
-name = "windows_x86_64_gnullvm"
-version = "0.53.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0a6e035dd0599267ce1ee132e51c27dd29437f63325753051e71dd9e42406c57"
-
[[package]]
name = "windows_x86_64_msvc"
version = "0.52.6"
@@ -6161,16 +7174,19 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
[[package]]
-name = "windows_x86_64_msvc"
-version = "0.53.0"
+name = "winnow"
+version = "0.7.12"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "271414315aff87387382ec3d271b52d7ae78726f5d44ac98b4f4030c91880486"
+checksum = "f3edebf492c8125044983378ecb5766203ad3b4c2f7a922bd7dd207f6d443e95"
+dependencies = [
+ "memchr",
+]
[[package]]
name = "winnow"
-version = "0.7.12"
+version = "1.0.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f3edebf492c8125044983378ecb5766203ad3b4c2f7a922bd7dd207f6d443e95"
+checksum = "23b97319f7b8343df12cc98938e5c3eb436064524c8d2b4e30a1d3a36eecdf81"
dependencies = [
"memchr",
]
@@ -6182,7 +7198,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "08db1edfb05d9b3c1542e521aea074442088292f00b5f28e435c714a98f85031"
dependencies = [
"assert-json-diff",
- "base64",
+ "base64 0.22.1",
"deadpool",
"futures",
"http",
@@ -6204,14 +7220,14 @@ version = "0.39.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6f42320e61fe2cfd34354ecb597f86f413484a798ba44a8ca1165c58d42da6c1"
dependencies = [
- "bitflags",
+ "bitflags 2.11.1",
]
[[package]]
name = "writeable"
-version = "0.6.2"
+version = "0.6.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9edde0db4769d2dc68579893f2306b26c6ecfbe0ef499b013d731b7b9247e0b9"
+checksum = "3ad82d2a33cdc9674dc7465672f271e096168fcdbe0f799d9e6db8c5892679dc"
[[package]]
name = "wyz"
@@ -6224,9 +7240,9 @@ dependencies = [
[[package]]
name = "yoke"
-version = "0.8.1"
+version = "0.8.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "72d6e5c6afb84d73944e5cedb052c4680d5657337201555f9f2a16b7406d4954"
+checksum = "709fe23a0424b6a435d82152b1bd3fdfb0833487d5fa90d05d42762a9891fef5"
dependencies = [
"stable_deref_trait",
"yoke-derive",
@@ -6235,13 +7251,13 @@ dependencies = [
[[package]]
name = "yoke-derive"
-version = "0.8.1"
+version = "0.8.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b659052874eb698efe5b9e8cf382204678a0086ebf46982b79d6ca3182927e5d"
+checksum = "33811428bee40dbceb6d545e95754741d17a6aef9a4849f0fd62e2ba4f412a78"
dependencies = [
"proc-macro2",
"quote",
- "syn 2.0.104",
+ "syn 3.0.6",
"synstructure",
]
@@ -6267,22 +7283,22 @@ dependencies = [
[[package]]
name = "zerofrom"
-version = "0.1.6"
+version = "0.1.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "50cc42e0333e05660c3587f3bf9d0478688e15d870fab3346451ce7f8c9fbea5"
+checksum = "0ec05a11813ea801ff6d75110ad09cd0824ddba17dfe17128ea0d5f68e6c5272"
dependencies = [
"zerofrom-derive",
]
[[package]]
name = "zerofrom-derive"
-version = "0.1.6"
+version = "0.1.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d71e5d6e06ab090c67b5e44993ec16b72dcbaabc526db883a360057678b48502"
+checksum = "f75b4683f6c7f45248d4d64056a24298c6281e0993356d7d1b4a1a962ef10d4a"
dependencies = [
"proc-macro2",
"quote",
- "syn 2.0.104",
+ "syn 3.0.6",
"synstructure",
]
@@ -6308,9 +7324,9 @@ dependencies = [
[[package]]
name = "zerotrie"
-version = "0.2.3"
+version = "0.2.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2a59c17a5562d507e4b54960e8569ebee33bee890c70aa3fe7b97e85a9fd7851"
+checksum = "4ea269c3bd32f0a32c321907a2ae912ba6f4649bb0fc764a15627e99a7095a3f"
dependencies = [
"displaydoc",
"yoke",
@@ -6319,9 +7335,9 @@ dependencies = [
[[package]]
name = "zerovec"
-version = "0.11.5"
+version = "0.11.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6c28719294829477f525be0186d13efa9a3c602f7ec202ca9e353d310fb9a002"
+checksum = "bb0464e17806c1d976d5cba29399c7f08e516e279e2ba493f63123b5fca67dd8"
dependencies = [
"yoke",
"zerofrom",
@@ -6330,11 +7346,45 @@ dependencies = [
[[package]]
name = "zerovec-derive"
-version = "0.11.2"
+version = "0.11.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eadce39539ca5cb3985590102671f2567e659fca9666581ad3411d59207951f3"
+checksum = "34df6fc39dbd26ddc9c10e6a2984476e13acce22e64e4487636ef494369225da"
dependencies = [
"proc-macro2",
"quote",
- "syn 2.0.104",
+ "syn 3.0.6",
+]
+
+[[package]]
+name = "zmij"
+version = "1.0.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b"
+
+[[package]]
+name = "zstd"
+version = "0.13.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e91ee311a569c327171651566e07972200e76fcfe2242a4fa446149a3881c08a"
+dependencies = [
+ "zstd-safe",
+]
+
+[[package]]
+name = "zstd-safe"
+version = "7.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "64d80649ab6db9d9f6f9c80a40becd948eda4714a0a5ac8c4d157a32231c7882"
+dependencies = [
+ "zstd-sys",
+]
+
+[[package]]
+name = "zstd-sys"
+version = "2.1.0+zstd.1.5.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0ef0a8027ec3ee71300ab3bcbcd0393f434aa72b91ca6d635a39941deae8eea0"
+dependencies = [
+ "cc",
+ "pkg-config",
]
diff --git a/Cargo.toml b/Cargo.toml
index d76c60501..bf2738ac7 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -2,22 +2,21 @@
[workspace]
members = [
"bin/mega-evme",
- "bin/mega-t8n",
"crates/mega-evm",
"crates/mega-state-test",
"crates/state-test",
"crates/system-contracts",
]
-default-members = ["crates/mega-evm", "bin/mega-evme", "bin/mega-t8n"]
+default-members = ["crates/mega-evm"]
exclude = []
# Explicitly set the resolver to version 2, which is the default for packages with edition >= 2021
# https://doc.rust-lang.org/edition-guide/rust-2021/default-cargo-resolver.html
resolver = "2"
[workspace.package]
-version = "1.7.1"
+version = "2.0.0-alpha.1"
edition = "2021"
-rust-version = "1.91"
+rust-version = "1.94"
license = "MIT OR Apache-2.0"
homepage = "https://github.com/megaeth-labs/mega-evm"
repository = "https://github.com/megaeth-labs/mega-evm"
@@ -122,67 +121,70 @@ too_long_first_doc_paragraph = "allow"
[workspace.dependencies]
# megaeth
-mega-evm = { path = "./crates/mega-evm", version = "1.7.1", default-features = false }
-mega-state-test = { path = "./crates/mega-state-test", version = "1.7.1", default-features = false }
-mega-system-contracts = { path = "./crates/system-contracts", version = "1.7.1", default-features = false }
+mega-evm = { path = "./crates/mega-evm", version = "2.0.0-alpha.1", default-features = false }
+# The `-legacy` entries are the legacy line (specs `Equivalence` through `Rex6`, crates.io revm
+# 27), linked only by the `mega-evme` tool's legacy leg and pinned exactly: the tool replays
+# history with what shipped.
+mega-evm-legacy = { package = "mega-evm", version = "=1.7.1", default-features = false }
+mega-evme-legacy = { package = "mega-evme", version = "=1.7.1", default-features = false }
+mega-state-test = { path = "./crates/mega-state-test", version = "2.0.0-alpha.1", default-features = false }
+mega-state-test-legacy = { package = "mega-state-test", version = "=1.7.1", default-features = false }
+mega-system-contracts = { path = "./crates/system-contracts", version = "2.0.0-alpha.1", default-features = false }
# revm
-op-revm = { version = "8.1.0", default-features = false }
-revm = { version = "27.1.0", default-features = false }
-revm-inspectors = { version = "0.27.3", default-features = false }
+# revm stays pinned to the crates.io version the megaeth fork is based on; `[patch.crates-io]`
+# below redirects all twelve revm crates to the fork. op-revm and the OP alloy crates have no
+# crates.io release for revm 40: they come from the OP monorepo revision the node locks, and
+# op-revm is redirected to the megaeth fork of it by the second patch block.
+op-revm = { git = "https://github.com/ethereum-optimism/optimism", rev = "f67d87cd5c9992b62d215c043917b94e3f019629", default-features = false }
+revm = { version = "=40.0.3", default-features = false }
+revm-inspectors = { version = "0.40.1", default-features = false }
# alloy
-alloy-consensus = { version = "1.0.23", default-features = false }
-alloy-eips = { version = "1.0.23", default-features = false }
-alloy-evm = { version = "0.15.0", default-features = false }
-alloy-hardforks = { version = "0.2.7", default-features = false }
-alloy-json-rpc = { version = "1.0.41", default-features = false }
-alloy-network = { version = "1.0.41", default-features = false }
-alloy-op-evm = { version = "0.15.0", default-features = false }
-alloy-op-hardforks = { version = "0.2.2", default-features = false }
-alloy-primitives = { version = "1.3.0", default-features = false, features = ["map-foldhash"] }
-alloy-provider = { version = "1.0.41", default-features = false }
-alloy-rlp = { version = "0.3.12", default-features = false }
-alloy-rpc-client = { version = "1.0.41", default-features = false }
-alloy-rpc-types-eth = { version = "1.0.24", default-features = false, features = ["serde"] }
-alloy-rpc-types-trace = { version = "1.0.22", default-features = false }
-alloy-serde = { version = "1.0.23", default-features = false }
-alloy-sol-types = { version = "1.0.23", default-features = false }
-alloy-transport = { version = "1.0.41", default-features = false }
-alloy-transport-http = { version = "1.0.41", default-features = false }
-op-alloy-consensus = { version = "0.18.12", default-features = false, features = ["k256"] }
-op-alloy-flz = { version = "0.13.1", default-features = false }
-op-alloy-network = { version = "0.18.12", default-features = false }
-op-alloy-rpc-types = { version = "0.18.12", default-features = false }
+alloy-consensus = { version = "2.0.5", default-features = false }
+alloy-eips = { version = "2.0.5", default-features = false }
+alloy-evm = { version = "0.36.0", default-features = false }
+alloy-hardforks = { version = "0.4.7", default-features = false }
+alloy-json-rpc = { version = "2.1.1", default-features = false }
+alloy-network = { version = "2.0.5", default-features = false }
+alloy-op-evm = { git = "https://github.com/ethereum-optimism/optimism", rev = "f67d87cd5c9992b62d215c043917b94e3f019629", default-features = false }
+alloy-op-hardforks = { git = "https://github.com/ethereum-optimism/optimism", rev = "f67d87cd5c9992b62d215c043917b94e3f019629", default-features = false }
+alloy-primitives = { version = "1.6.0", default-features = false, features = ["map-foldhash"] }
+alloy-provider = { version = "2.0.5", default-features = false }
+alloy-rlp = { version = "0.3.16", default-features = false }
+alloy-rpc-client = { version = "2.1.1", default-features = false }
+alloy-rpc-types-eth = { version = "2.0.5", default-features = false, features = ["serde"] }
+alloy-rpc-types-trace = { version = "2.0.5", default-features = false }
+alloy-serde = { version = "2.1.1", default-features = false }
+alloy-sol-types = { version = "1.6.0", default-features = false }
+alloy-transport = { version = "2.1.1", default-features = false }
+alloy-transport-http = { version = "2.1.1", default-features = false }
+alloy-trie = { version = "0.9.5", default-features = false }
+op-alloy-consensus = { git = "https://github.com/ethereum-optimism/optimism", rev = "f67d87cd5c9992b62d215c043917b94e3f019629", default-features = false, features = ["k256"] }
+op-alloy-network = { git = "https://github.com/ethereum-optimism/optimism", rev = "f67d87cd5c9992b62d215c043917b94e3f019629", default-features = false }
+op-alloy-rpc-types = { git = "https://github.com/ethereum-optimism/optimism", rev = "f67d87cd5c9992b62d215c043917b94e3f019629", default-features = false }
# misc
auto_impl = { version = "1.3", default-features = false }
-bitflags = { version = "2.6", default-features = false }
clap = { version = "4", default-features = false, features = ["derive"] }
delegate = { version = "0.13", default-features = false }
derive_more = { version = "2", default-features = false }
dirs = { version = "6", default-features = false }
-getrandom = { version = "0.3", default-features = false }
-hash-db = { version = "0.15", default-features = false }
-hex = { version = "0.4", default-features = false }
-indicatif = { version = "0.17", default-features = false }
-k256 = { version = "0.13.4", default-features = false }
-once_cell = { version = "1.21", default-features = false }
-plain_hasher = { version = "0.2", default-features = false }
-rand = { version = "0.10", default-features = false }
+insta = { version = "1.47.2", default-features = false, features = ["json"] }
+proptest = { version = "1.7", default-features = false }
rstest = { version = "0.25", default-features = false }
semver = { version = "1", default-features = false }
serde = { version = "1.0", default-features = false }
serde_json = { version = "1.0", default-features = false }
-sha2 = { version = "0.10.9", default-features = false }
tempfile = { version = "3", default-features = false }
thiserror = { version = "2.0", default-features = false }
tokio = { version = "1", default-features = false }
+tower = { version = "0.5", default-features = false }
tracing = { version = "0.1", default-features = false }
tracing-subscriber = { version = "0.3", default-features = false }
-triehash = { version = "0.8", default-features = false }
walkdir = { version = "2.5", default-features = false }
wiremock = { version = "0.6", default-features = false }
+zstd = { version = "0.13", default-features = false }
# Speed up compilation time for dev builds by reducing emitted debug info.
# NOTE: Debuggers may provide less useful information with this setting.
@@ -194,6 +196,8 @@ split-debuginfo = "unpacked"
# Speed up tests.
[profile.dev.package]
+blst.opt-level = 3
+c-kzg.opt-level = 3
proptest.opt-level = 3
rand_chacha.opt-level = 3
rand_xorshift.opt-level = 3
@@ -224,3 +228,24 @@ strip = "none"
inherits = "release"
lto = "fat"
codegen-units = 1
+
+[patch.crates-io]
+# megaeth fork of revm (revm 40.0.3 + the revm 43 gas core + the megaeth hooks).
+# All twelve crates move together, otherwise the build resolves a second copy of revm.
+revm = { git = "https://github.com/megaeth-labs/revm", rev = "fd230a3427d1b96c88e0b581bab8a7763c8ec298" }
+revm-primitives = { git = "https://github.com/megaeth-labs/revm", rev = "fd230a3427d1b96c88e0b581bab8a7763c8ec298" }
+revm-interpreter = { git = "https://github.com/megaeth-labs/revm", rev = "fd230a3427d1b96c88e0b581bab8a7763c8ec298" }
+revm-context = { git = "https://github.com/megaeth-labs/revm", rev = "fd230a3427d1b96c88e0b581bab8a7763c8ec298" }
+revm-context-interface = { git = "https://github.com/megaeth-labs/revm", rev = "fd230a3427d1b96c88e0b581bab8a7763c8ec298" }
+revm-handler = { git = "https://github.com/megaeth-labs/revm", rev = "fd230a3427d1b96c88e0b581bab8a7763c8ec298" }
+revm-database = { git = "https://github.com/megaeth-labs/revm", rev = "fd230a3427d1b96c88e0b581bab8a7763c8ec298" }
+revm-database-interface = { git = "https://github.com/megaeth-labs/revm", rev = "fd230a3427d1b96c88e0b581bab8a7763c8ec298" }
+revm-state = { git = "https://github.com/megaeth-labs/revm", rev = "fd230a3427d1b96c88e0b581bab8a7763c8ec298" }
+revm-bytecode = { git = "https://github.com/megaeth-labs/revm", rev = "fd230a3427d1b96c88e0b581bab8a7763c8ec298" }
+revm-precompile = { git = "https://github.com/megaeth-labs/revm", rev = "fd230a3427d1b96c88e0b581bab8a7763c8ec298" }
+revm-inspector = { git = "https://github.com/megaeth-labs/revm", rev = "fd230a3427d1b96c88e0b581bab8a7763c8ec298" }
+
+[patch."https://github.com/ethereum-optimism/optimism"]
+# megaeth fork of op-revm (the OP monorepo copy ported to the revm fork's gas core), built
+# against the revm pin above.
+op-revm = { git = "https://github.com/megaeth-labs/op-revm", rev = "2ecb7dceed1c458a2b59ca4d8993a073968cb111" }
diff --git a/README.md b/README.md
index e99cff180..b976a9e72 100644
--- a/README.md
+++ b/README.md
@@ -4,13 +4,13 @@ A specialized Ethereum Virtual Machine (EVM) implementation tailored for MegaETH
## Crates
-| Crate | Description |
-| ------------------------------------------------ | ------------------------------------------------------------------------- |
-| [mega-evm](crates/mega-evm) | Core EVM implementation with MegaETH specs (`EQUIVALENCE` through `REX7`) |
-| [mega-system-contracts](crates/system-contracts) | Solidity system contracts with Rust bindings |
-| [mega-evme](bin/mega-evme) | CLI tool for EVM execution (`run`, `tx`, `replay`) |
-| [mega-t8n](bin/mega-t8n) | Standalone state transition (t8n) tool |
-| [state-test](crates/state-test) | Ethereum state test runner |
+| Crate | Description |
+| ------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------- |
+| [mega-evm](crates/mega-evm) | Core EVM implementation: the Satin engine (`SATIN`, unstable); the legacy engine is `EQUIVALENCE` through `REX6` |
+| [mega-system-contracts](crates/system-contracts) | Solidity system contracts with Rust bindings |
+| [mega-evme](bin/mega-evme) | CLI tool for EVM execution (`run`, `tx`, `replay`) |
+| [mega-state-test](crates/mega-state-test) | Execution-spec state-test runner on the Satin engine |
+| [state-test](crates/state-test) | CLI of the execution-spec state-test runner |
## Installation
@@ -25,7 +25,7 @@ The `--locked` flag ensures the exact tested dependency versions are used.
Or build from source:
```bash
-cargo build --release -p mega-evme
+cargo build --release --manifest-path bin/mega-evme/Cargo.toml
```
### Prebuilt binary
diff --git a/REVIEW.md b/REVIEW.md
index 259701ddf..30b51e477 100644
--- a/REVIEW.md
+++ b/REVIEW.md
@@ -7,36 +7,51 @@ Defer to the baseline for everything not listed here; the rules below take prece
## Correctness and safety
-### Spec backward compatibility
+### Spec compatibility
-This is the single most important correctness concern in mega-evm.
-
-- **Existing stable specs must never change behavior.**
- Check `CLAUDE.md` for which spec is currently unstable — all others are frozen.
- New EVM behavior, gas cost changes, or opcode modifications must introduce a new spec and be gated with `spec.is_enabled(MegaSpecId::NEW_SPEC)`.
-- System contract changes (Solidity sources or Rust integration) require a new spec.
-- Modified constants must be gated per-spec — verify that old spec paths still use the old values.
-- If a PR claims to "fix" behavior for an existing spec, scrutinize whether this changes consensus.
- A true bug fix in a frozen spec is rare and must be justified.
+- Satin is the one spec of this engine and it is unstable: it has no activation timestamp yet, so a PR may change its behavior, and `docs/spec/upgrades/satin.md` and `AGENTS.md` change with it.
+ The legacy engine (`Equivalence` through `Rex6`) is frozen on `main` and is not edited here; flag a PR that adds a legacy spec, an alias rung or a ported legacy mechanism.
+- There are no spec gates yet.
+ The next spec is added as the spec system in `AGENTS.md` describes; from then on Satin's path is fixed, and a change to behavior or to a constant that Satin shipped is gated on the new spec, with Satin's path left as it is.
+ Flag a PR that adds an `is_enabled` gate before a second spec exists.
+- A change that makes Satin differ from op-revm on purpose updates `tests/satin/equivalence.rs`; a change that makes it differ from Ethereum's fixtures on purpose registers a deviation (see Test gates).
+- System contract changes need a decision of their own: the Solidity sources and bindings carry over unchanged, so a change to one is not a side effect of an engine change.
+- A change to a limit, a price or a constant says which of the spec's numbers moved, and regenerates the documents rendered from them.
### Consensus-critical execution
- All execution logic must be **deterministic and architecture-independent** — no `mem::transmute`, no native-endian byte conversions, no platform-dependent operations in consensus paths.
-- Pre-block helpers (system contract deploys, pre-exec system calls, etc.) must return `Option` for the block executor to commit — never call `db.commit(...)` directly.
- Even idempotent "no change" paths must return `Some(EvmState)` with a read-only account entry; silently returning `None` drops the account from the stateless witness read set and produces an incomplete proof.
- See `crates/mega-evm/src/system/AGENTS.md` → `PRE-BLOCK STATE CHANGE CONTRACT`.
- The same applies inside execution: read through the journal (`inspect_account`), never `journal.database.basic(...)`, or the account driving the result is missing from the returned state — and an early halt placed before the sandbox state merge drops that read set entirely.
-- Per-frame gas mechanisms (stipends, adjustments) must handle all frame termination paths: system contract interception, gas rescue on limit exceed, and frame return.
- Missing any path causes gas leakage.
-- **Metering must be symmetric across every exit path of the instruction it wraps, and must not double-count.**
- A `record_*` / `compute_gas!` sitting on the success arm, or after the inner revm instruction returns, is skipped by stack underflow, OOG, decode failure and inner-call failure; conversely, charge per applied action rather than per candidate, and dedup across every frame shape (top-level, `caller == target` self-transfer, repeated recipients).
-- **Ordering: guards before work, enforcement before mutation.**
- `inspect_account` / `resize_memory!` / `keccak256` / storage-gas computation belong after the wrapped instruction's own validity checks (salt underflow, EIP-3860 size, EIP-214 static, empty initcode), and a limit must be enforced before the state change it guards — a latched flag surfacing as a `Halt` after `pre_execution` journaled the writes leaves them committed under a failed receipt.
-- **Keyless / sandbox child execution must reconcile every effect dimension into the parent and block:** gas, each limit dimension, volatile access, logs and the read set.
- A `SandboxOutcome` carrying state but dropping logs, or a tracker allocated fresh instead of merged, is a consensus bug; and a value validated before execution (a gas-limit override) must not be mutated afterwards.
-- **The volatile-access / beneficiary-detention boundary must cover every sensitive surface** — a new volatile-derived read or side effect (Oracle SLOAD or hint, SELFDESTRUCT beneficiary, EIP-7702 delegate) has to consult the tracker; resolve the delegate before marking, and check the destructing contract itself, not only the stack target.
-- **System calls and system-address transactions:** a mandatory pre-block system call with dynamic cost needs a `block.gas_limit`-derived budget, not revm's fixed default, or a spec flipping it fail-closed rejects blocks persistently; a system-address transaction must validate nonce, chain-id and EIP-3607 against replay, and a commit step re-checking block limits must re-check the nonce too.
-- **Hot-path accounting must stay O(1)** in attacker-controlled call depth and authorization count — no frame-stack walk per opcode, no unindexed `Vec` scan per authorization.
+- Pre-block helpers (the activation block's predeploy check, pre-block system calls, the registry's due-change read, the L1 block info read) return their state (an `EvmState`, or a `ResultAndState` for a system call) for the block executor to commit on its own, in order; they never call `db.commit(...)`.
+ An idempotent "no change" path returns an `EvmState` that carries the observed account as a read-only entry; returning nothing drops the account from the stateless witness read set and produces an incomplete proof.
+ The same applies inside execution: read through the journal with revm's own loads (`load_account`, `sload`), never `journal.database.basic(...)`, or the account driving the result is missing from the returned state.
+- **A write is counted once its opcode completed.**
+ The Host's `sstore`, `log` and `selfdestruct` only write and count nothing; revm's write instructions call the completed-write hook (`Host::write_completed`) after every charge they make, and the frame-starting instructions call the frame-start hook (`Host::frame_starting`) after the forward and before the frame's input is built.
+ A record, a charge or a read mark made before the opcode can still fail counts a write that never happened.
+ The frame-start hook only prices: a start's records are counted once revm decided it, from what revm did to the start's accounts (`Accounts::start_made`), and a creator's nonce record on the creator once the creation returned with the nonce bumped (`hold_creator`), so no count precedes revm's decision, none is predicted and none is given back.
+ An answer that failed kept nothing and is held to no records limit: a failed precompile answer ends as the precompile's own failure, or as the compute stop (kind 2) where gas detention ran a precompile it cannot price on the allowance and the precompile ran out of it.
+ A precompile gas detention answers from its price moved nothing and is held to the price alone: its answer is the compute stop (kind 2).
+ Flag a records stop — data size, KV updates or state growth (kinds 0, 1 and 3) — given at either answer site.
+ Check that nothing is counted in the Host's write methods, that no charge lands in a write instruction after the hook (the fork's call sites), and that the engine's matches over `CompletedWrite` and `FrameStartKind` carry no wildcard arm.
+- **A limit is enforced before the write it guards.**
+ A limit — the transaction's or a frame's budget — stops the frame that crosses it with a revert carrying `MegaLimitExceeded`, never with a halt, and its caller resumes within every limit, unless the failure put back a record a frame above made while an Oracle hint the failed frame sent stays, when the caller returns the transaction's stop as it resumes; a stop of the transaction's own frame keeps the gas its frames hold, and nothing is taken from the sender on a stop.
+ Flag a stop that surfaces as a halt, a limit that is checked after the state change it guards, a stopped frame whose writes, logs or counted bytes survive into its caller, and an answer the engine turns into the stop whose journal is not taken back.
+ The outcome's `limit_exceeded`, not the output bytes, tells a stop from a contract that reverts with the same bytes.
+- **Pools and ledgers stay aligned with frames.**
+ A frame's byte pool is on its gas tracker and settles with it; `frame_init` opens one entry per start revm decided (`AdditionalLimit::open_start`), which the result returning at that depth closes (`close_start`), and a start revm did not decide opens none; a synthetic frame result carries the caller's pools (`synthetic_frame_result`), never `Gas::new(limit)`.
+ A mechanism that adds a state charge goes through `Host::state_gas_price` at the site the state lands on and does not price the charge itself; a charge is given back at the price it was made at, unless an inspector rewrote the call's target, which revm reads the refund's account off.
+ The three ledgers (regular, state, history) add up to the raw spend, and the block counts `max(regular, floor)` with history taken out first.
+- **Gas detention caps a frame inside the frame's own tracker.**
+ It withholds a part of the frame's regular gas (`Gas::limit_spendable`) that every reader but a regular charge counts, so there is nothing to move or release; a mechanism that caps a frame's gas uses the same part, holds the frame at its start and after every credit, and never releases a creating frame's withheld part before `return_create`.
+ A read of volatile data is marked where the Host loads the value and committed by the opcode's wrapper once the opcode completed; a new volatile-derived read or side effect (the block environment, the beneficiary's account through any account opcode, the Oracle's storage, an EIP-7702 delegate) has to be marked, and the delegate resolved before marking.
+ Flag a bound or an economic claim in a comment or the spec that the code does not meet.
+- **Keyless deployment is a native creation.**
+ The `keylessDeploy` call's frame runs no code and makes its actions by hand; check that the creation's outcome returns into the call through `frame_return_result`, that every effect (gas, the data-size pool, volatile access, logs, state) is reconciled in the one frame stack, that the signer's nonce rule holds on success and on failure, and that a value validated before execution (a gas-limit override) is not mutated afterwards.
+- **The interceptor dispatch is ordered cheapest-first and fails closed.**
+ The call-scheme guard, then the address, then the selector, then the method's value policy; only `CALL` and `STATICCALL` reach an interceptor; an unknown selector is not intercepted and falls through to the contract's bytecode; a method that takes no value answers a value-bearing call with its error.
+- **System calls and system-address transactions:** a system call and a system-originated transaction are exempt from the per-transaction limits and history gas, priced at the minimum SALT bucket and not detained; a pre-block call runs on the one pre-block budget (`constants::PRE_BLOCK_CALL_GAS_LIMIT`), whatever the block's gas limit; a database error the database calls fatal is an internal error and any other failure refuses the block with the call's own validation error; a system-address transaction validates nonce, chain id and EIP-3607 against replay, and a commit step that re-checks block limits re-checks the sender's nonce and balance too.
+- **The stateless witness must hold every read.**
+ A change that makes block execution read state outside a transaction's journal commits the read as a read-only entry of a pre-block state or exports it, and adds a witness-replay case; nothing may depend on which source (the database, the SALT environment, the oracle service) answered.
+- **Hot-path accounting stays O(1)** in attacker-controlled call depth and authorization count — no frame-stack walk per opcode, no unindexed `Vec` scan per authorization.
## Design and architecture
@@ -55,15 +70,22 @@ This is the single most important correctness concern in mega-evm.
- If a change affects cross-component behavior that cannot be covered by unit tests, suggest e2e tests in the review comment (these may live in the `test-client` repo).
- For stateful systems (resource-limit trackers, gas-stipend lifecycle), assert state-machine invariants after each transition, not just at the end.
- Tests under `crates/mega-evm/tests/mutation/` are generated mutation-killing system tests, each keyed to a specific surviving mutant.
+ On the `satin` branch the directory does not exist yet: the legacy killers were keyed to mutants of the legacy sources and were retired, and the Satin sources leave no survivor; the first mechanism whose survivor needs a system-level killer creates it, with the conventions of `main`'s `crates/mega-evm/tests/mutation/main.rs`.
Their comments — especially the `file:line:col` mutation-location references — must be kept up to date when the referenced source moves.
Flag any PR that shifts lines in a mutated source file but leaves a now-stale location reference (or an orphaned/renamed test) in `tests/mutation/`; a reference that no longer points at its mutant defeats the purpose of the linkage.
These tests should not be hand-edited otherwise — see `crates/mega-evm/tests/mutation/main.rs`.
+- `crates/mega-evm/tests/satin/pricing-table.md` is generated by its own test, not written by hand.
+ A change that moves a number in it must regenerate the file (`UPDATE_SATIN_PRICING_TABLE=1 cargo test -p mega-evm --test satin`) and explain the movement; a hand-edited row hides the change it was meant to surface.
+- A test that asserts one of the spec's own byte-price numbers must return early when the process runs at other prices (`runs_at_measurement_prices`).
+ A measurement build fixes other prices through the `satin-price-override` feature, and a test without the guard fails there on a price the developer asked for.
+ Flag a new state-gas assertion that lacks it: the failure only shows in the configuration nobody watches.
+- Every other test holds at a byte price of nothing and at any price from one gas per byte up to the grid's dearest point, and the byte-price grid job checks it.
+ Below one gas per byte the schedule's entries round to nothing one at a time, and past the grid a fixed-size scenario outgrows any transaction below the execution cap; no test is held there.
+ A gas limit is its regular room on top of what the scenario adds at the prices in effect, read off the schedule and `history_gas`, not a number that happened to cover it at the constants; a call or creation that forwards all but 2 per cent of its gas keeps a fiftieth of it, so it must hold 50 times the history of the records it pays for.
+ A case whose scenario is state or history gas — a limit to cross, a bucket to scale, a charge that cannot be paid — returns early where that byte costs nothing (`state_is_free`, `history_is_free` in each test target's `common.rs`), and its other assertions still run.
- **Benchmark methodology.**
A perf-comparison PR must pin comparable hardforks on both arms.
Missing the required explicit hardfork pin can silently bench the wrong fork when a shared bench subject defaults to a different one.
- For the paired Criterion-style harness, use an even round count.
- Odd defeats A/B alternation there.
- Do not apply that even-round rule to the replay ABBA harness.
Adjudicate quantitatively.
Don't drop a `saturating_sub`/guard "for speed" without a measured, attributable gain.
- **Storage-layout parity.**
@@ -74,9 +96,105 @@ This is the single most important correctness concern in mega-evm.
The fixture runners have failed this repeatedly: an exception assertion accepting any `Err`, a setup failure skipping execution, a `zip` letting missing output pass, a duplicate test name silently overwriting, an `unwrap_or(default)` rewriting a contradictory fixture into a valid one, a filename-based skip, an unconditional prune before state-root validation.
Benchmarks fail it the same way — an unfunded inner call, zero-byte initcode, a discarded inner-call result or an undeployed address means the measured path never runs, and a mock database that cannot fail a lookup cannot test its error path.
+## Test gates
+
+These checks guard every change to the Satin engine.
+`lint`, `test`, `no-std` and `require-label` are the required checks on `satin`; the rest inform the review, and the reviewer reads them.
+
+### The op-revm baseline
+
+- `crates/mega-evm/tests/satin/equivalence.rs` runs ordinary transactions through `MegaEvm` and through op-revm on the same configuration, and holds Satin to op-revm's total plus the history ledger, on op-revm's own state gas, logs and state.
+- It runs in the `test` check.
+- A change that makes Satin differ from op-revm on purpose updates a case or adds one, so the difference is pinned; a case changed to absorb a difference nobody chose is the defect.
+
+### Differential harness
+
+- The differential harness, which runs JSON scenarios through `MegaEvm` and through stock revm and compares them field by field, is maintained outside this repository.
+- It is not a check on this repository's pull requests.
+- The scenario format it reads (`test_utils::Scenario`) stays in `mega-evm`, where the `corpus` bench reads its own scenarios.
+
+### Execution-spec tests
+
+- `.github/workflows/exec-spec.yml` runs the fork's own runner on the execution-spec-test fixtures, at the fork tag `Cargo.lock` pins, and checks the Osaka and Amsterdam executed and skipped counts pinned in the workflow.
+ It checks the fork `MegaEvm` runs on, not `MegaEvm`.
+ It runs when `Cargo.toml` or `Cargo.lock` changes (the pin may have moved); a change that moves the pin updates the pinned counts and says why they moved.
+- `.github/workflows/exec-spec-satin.yml` runs the same fixture releases through `MegaEvm` with the state-test runner (`crates/mega-state-test`).
+ Equivalence mode is the gate: Satin's machinery priced as the fixture's fork prices it, where every failure must be explained by a deviation registered in `crates/mega-state-test/src/deviations.rs`, with its reason and the exact entries it explains, each with the hashes Satin produces; every listed entry must fail exactly as listed, and the executed and skipped counts equal the fork runner's pins.
+ Satin mode reports the same fixtures under Satin's own configuration in the step summary, and does not fail the job.
+ The gate runs when a pull request changes the engine, the runner, the system contracts, the toolchain or the lock; the workflow's `execution-spec gate on Satin` job runs on every pull request and reports it, passing when the gate passed or had nothing to run.
+- The same workflow imports the main release's Osaka blockchain tests through Satin's block executor (`state-test btest`, `crates/mega-state-test/src/blockchain/`), in equivalence mode's configuration: every accepted block's gas used, logs bloom, receipts root and state root are held to its header, every block the fixture expects to be invalid must be refused for an exception it names, and the chain must end at the fixture's last block and post-state.
+ A block that differs passes only when a deviation the registry already has lists that test and block with exactly the outcome Satin produces — gas used, logs bloom, receipts root and state root — and the chain goes on from Satin's state, so a listed block exempts nothing after it; a block listed as differing only by an earlier block's state must run as on Ethereum otherwise, and a chain that ends on a listed block's state says why its post-state is not compared.
+ The summary counts the blocks checked against Ethereum apart from those matched to a deviation; the executed tests and the skips of each class are pinned in the workflow.
+ A skip is decided from the fixture before anything runs, and a class added to the list says what Ethereum's block has that an OP block does not, or which check a node makes before the executor does.
+ The accounts the runner and a Satin block add — the predeploys, which the runner seeds as Rex6 left them where the fixture's pre-state lacks them, and the fee vaults op-revm credits — are taken out of the state root only when the fixture's pre-state does not hold them and they hold exactly what was put there (`SATIN_ACCOUNTS`); widening that rule is reviewed like a deviation.
+- A deviation is a rule Satin keeps on purpose and is reviewed as one: an entry added to explain a failure that is a bug is the defect, and an entry added, removed or given new hashes says which fixtures moved and why.
+ `crates/mega-state-test/DEVIATIONS.md` is rendered from the registry, and a test keeps the two equal.
+- Neither workflow is a required check; `execution-spec gate on Satin` is the job a branch rule would require.
+
+### Witness replay
+
+- `crates/mega-evm/tests/block/witness/` executes a block on a recorder of every read and replays the transactions it included twice, on a strict database and environments that serve exactly a witness and refuse everything else: once on the record of every database read, once on the witness a node builds from the states the block committed — the pre-block steps' and the included transactions' returned states — and the engine's exports.
+ `witness::check_replay` in `crates/mega-state-test` does the same for a fixture's transaction; an entry the engine rejects has no returned state and replays on the record alone.
+ Its test over the execution-spec fixtures is always ignored by default: it runs only with `-- --ignored` (or `--include-ignored`) and `MEGA_STATE_TEST_FIXTURES` set to the fixtures, and setting the variable alone runs nothing.
+- The replay on the node's witness is the one that finds a read the witness lacks; the replay on the record of every read shows the block has no input outside its database and environments.
+ A change that makes block execution read state outside a transaction's journal commits the read as a read-only entry of a pre-block state, or exports it, and adds the case that makes the read.
+- The block cases run in the `test` check.
+ `.github/workflows/exec-spec-satin.yml` runs the fixture replay after the equivalence gate, on the same fixture releases: every Osaka and Amsterdam entry, in equivalence and in Satin mode; an entry that does not replay fails the job, and so `execution-spec gate on Satin`, and so does a run that prints no single well-formed summary, executes nothing or reports a failed entry.
+ The step summary counts the entries replayed on both witnesses apart from the rejected ones.
+
+### Byte-price grid
+
+- `.github/workflows/price-grid.yml` runs the `mega-evm` suite at byte prices other than the constants, through `scripts/price_grid.sh`: a cost per state byte and a cost per history byte per point, each run with `--no-fail-fast`.
+- On a pull request it runs five points: both bytes free (0 / 0), both at one gas (1 / 1), the cheapest and the dearest pair under consideration (312.5 / 20 and 5000 / 300), and a point past every candidate (10000 / 1000).
+ Between them they have failed every test the whole grid failed; 1 / 1 is where a premise that a charge cannot be paid, true only while a byte is dear, breaks.
+- Nightly and on dispatch it runs the whole grid: CPSB 0, 1, 312.5, 700, 1530, 2000, 5000 and 10000 by CPHB 0, 1, 20, 50, 88, 100, 200, 300 and 1000, and 0.001 on both.
+- It is not a required check.
+ A failure is a test that assumes a price, a scenario that does not scale with it, or an engine defect; the first two are fixed in the test, the third is not hidden behind a guard.
+- Each point reports how many tests a price guard held back (`guarded`, from `note_price_guard`; the tests are listed in the point's `.guards` file beside its log): every point passes the same number of tests, and this column tells a point at which tests returned early from one at which they ran.
+- Locally, `scripts/price_grid.sh --pr`, `--full`, or the points named (`scripts/price_grid.sh 312.5/20 5000/300`); each point's log is under `target/price-grid/`.
+
+### Instruction counts (CodSpeed)
+
+- The bench set is `transact` (`MegaEvm` next to op-revm's `OpEvm`, from an empty transaction to 64-deep calls and loops of storage writes and logs), `corpus` (the JSON scenarios under `benches/scenarios` through `MegaEvm`, a bench input rather than a conformance suite), `factory` (EVM construction through `MegaEvmFactory`) and `block` (a block through `MegaBlockExecutor`), all in `crates/mega-evm/benches`.
+- `block` measures a chain's steady state: a block on a state holding the predeploys as Rex6 left them, under `BlockLimits::default()`; the one-off check of the activation block is not measured.
+- `codspeed.yml` runs them under instrumentation on every pull request that touches code and on every push to `satin`; the baseline a pull request is compared with is the latest `satin` push.
+- Read regressions from the CodSpeed report on the pull request (the CodSpeed comment and the `CodSpeed Performance Analysis` check).
+ The regression threshold that fails that check is a setting of the repository's CodSpeed project; it is not recorded in this repository or in the reports CodSpeed posts, so this file does not state a number.
+ The check is not required: a flagged regression is fixed, or acknowledged in CodSpeed with the reason stated on the pull request.
+- `corpus` moves when the semantics or the pricing of its scenarios move; a pricing change that moves it says so on the pull request.
+- Locally, `cargo bench -p mega-evm --bench ` proves a bench runs to completion; its wall-clock numbers are not evidence.
+
+### Mutation testing
+
+- The `cargo-mutants gate` job mutates the lines a pull request changes and fails on a surviving mutant that no reviewed suppression covers.
+ Reference point, the pull request that brought the Satin skeleton: 115 mutants, 49 caught, 0 survived, 1 suppressed, 65 unviable, in 7m41s on CI and 4m12s on a 15-core laptop with `JOBS=8`.
+ That population is the diff against `a8f8c7c9`, the last commit of the legacy core, and it is reproduced by `scripts/mutation_test.sh diff a8f8c7c9` followed by `python3 scripts/mutation_gate.py report --results target/mutants/mutants.out --recheck target/mutants/recheck/mutants.out --suppressions mutants/suppressions.toml`.
+ Take the numbers from that pair, not from `cargo mutants` on its own: the driver turns the function-scoped suppressions into `--exclude-re` before generation, and the gate filters the line-scoped ones after the run, so the bare command reports a different population and a different survivor count.
+- The job is bounded to 330 minutes.
+ Shard a series whose diff lists more than 1,000 mutants (`cargo mutants --list --in-diff --package mega-evm`): at the reference rate that is about an hour, and the rate falls as the test suite grows.
+ Run shard `k` of `n` with `MUTANTS_SHARD=k/n OUT_DIR=target/mutants-k scripts/mutation_test.sh diff ` and gate each shard with `scripts/mutation_gate.py report`; the pull request that first needs it adds a shard matrix to the job, and every shard must pass.
+- The gate has a second scope, for its own infrastructure: `.cargo/mutants-infra.toml` and `scripts/mutation_test.sh infra` mutate the scenario runner (`crates/mega-evm/src/test_utils/scenario.rs`) against `mega-evm`'s tests.
+ The production scope excludes test helpers as noise, so that code is otherwise never mutated, though the benches and later tests rest on it.
+ The two scopes are disjoint and the production one keeps its exclusions; a suppression may belong to either, and the suppression-hygiene job lists both scopes into its mutant universe.
+ The `cargo-mutants infrastructure` job runs the scope nightly and on a pull request that changes `.cargo/mutants-infra.toml`, the scenario runner (`crates/mega-evm/src/test_utils/scenario.rs`), `scripts/mutation_test.sh` or `scripts/mutation_gate.py`; it never reads `.cargo/mutants.toml`, and a change to `mutants/suppressions.toml` alone does not start it on a pull request (the suppression-hygiene job and the nightly run cover that file); it is bounded to 90 minutes and is not a required check.
+ Reference point: 39 mutants, 34 caught, 0 survived, 3 suppressed, 2 unviable, in 5m45s on a 15-core laptop with `JOBS=8`.
+ The three suppressed ones write a `BlockEnv` field that already holds that value by default, so no test can distinguish them; the test that pins those values kills them the moment a revm upgrade moves a default.
+- The spec-gate operator pack stays in place but finds nothing on Satin: a single-spec engine has no spec gate to mutate, and the suppression-hygiene job accepts the empty plan.
+ It starts to bite with the first `is_enabled` gate of the spec after Satin.
+- The legacy mutant killers were retired with the legacy sources; a survivor in Satin code gets a new killer, next to the code or under `crates/mega-evm/tests/mutation/`.
+
+### Scheduled workflows
+
+- GitHub fires a `schedule` trigger only from the default branch's copy of a workflow, so the schedules in `satin`'s copies (nightly mutation, doc-audit, the weekly execution-spec run, the nightly byte-price grid) stay inert until `satin` is the default branch.
+- Run them on `satin` by hand: `gh workflow run .yml --ref satin` runs `satin`'s copy of the workflow on `satin`'s head, so none of them needs a `ref` input.
+ - `mutation.yml`: the whole-crate cargo-mutants run and suppression hygiene.
+ - `exec-spec.yml`: the execution-spec fixtures at the pinned fork tag.
+ - `doc-audit.yml`: the documentation audit of `satin`'s docs.
+ - `price-grid.yml`: the whole byte-price grid.
+
## Dev tools and test infrastructure
-Applies to `bin/mega-evme`, `bin/mega-t8n`, `crates/mega-state-test`, `crates/state-test`, test utilities and benches — not consensus code, but `mega-state-test` is a published library and tool output feeds fixtures and indexers. Default severity cap `[Minor]`; raise only when the defect reaches that published API or corrupts a downstream fixture.
+Applies to `bin/mega-evme`, `crates/mega-state-test`, `crates/state-test`, test utilities and benches — not consensus code, but `mega-state-test` is a published library and tool output feeds fixtures and indexers. Default severity cap `[Minor]`; raise only when the defect reaches that published API or corrupts a downstream fixture.
- An input-handling path (fixture, CLI flag, file path, RPC response) must fail with a structured error instead of aborting the process: a panic, unchecked index or overflow on **untrusted** input is the defect, as is `process::exit` from a library path — an idiomatic `unwrap` on a known-good value is not. A batch loop records a per-item rejection rather than aborting and dropping the rest.
- A computed output field — state root, receipt field, contract address, log index, provenance — must carry its real value or an explicit error; substituting a zero, `None`, `default()` or a silently clamped bound reports success for a result the tool never computed. Serialized output must be deterministically ordered, and an advertised flag must not be a stub returning `Ok(())`.
diff --git a/bench/replay/README.md b/bench/replay/README.md
deleted file mode 100644
index 739fbdc90..000000000
--- a/bench/replay/README.md
+++ /dev/null
@@ -1,132 +0,0 @@
-# Replay corpus & throughput benchmark
-
-`fixtures/` is a single corpus of characteristic MegaETH workloads, used two ways:
-
-- **Correctness** — `crates/state-test/tests/replay_corpus.rs` re-executes each
- fixture and checks its recorded post-state (state/logs root, gas, status) on
- **every PR** (via `cargo test`). A change that alters execution turns this red.
-- **Performance** — `run.py` times each fixture and compares a PR against its
- merge-base (`.github/workflows/replay-bench.yml`, on demand), so a speed-up or
- slow-down on real workloads is visible. This is the real-workload counterpart
- to the synthetic Criterion suite (`crates/mega-evm/benches/`).
-
-Keeping one corpus means a fixture added for either purpose serves both.
-
-## The unit: a self-contained fixture
-
-Every case is one **self-contained state-test fixture** (`fixtures/.json`):
-it carries its own pre-state, transaction, block environment, and MegaETH
-external environment, so it replays in isolation with **no RPC and no archive
-node**. The same EEST `TestUnit` shape `mega-evme replay --dump-fixture`
-produces:
-
-```jsonc
-{
- "": {
- "env": { currentNumber, currentTimestamp, currentBaseFee, … },
- "pre": { "0x…": { balance, code, nonce, storage }, … }, // the prestate
- "transaction": { type, sender, to, data, gasLimit, value, … },
- "megaEnv": { bucketCapacities, oracleStorage },
- "post": { "Rex5": [ { hash, logs, megaGasUsed, megaStatus } ] }
- }
-}
-```
-
-Because the fixture is self-contained, the source of the workload does not
-matter — a real mined transaction (`mega-evme replay --dump-fixture`), a
-`debug_traceCall` + `prestateTracer` snapshot, or a hand-crafted case all become
-the same kind of JSON. The corpus stores each as a committed fixture and times
-it with `state-test --bench`.
-
-## How it works
-
-1. **Build the fixture.** For a real transaction, dump it once (offline once
- captured, or straight from RPC):
-
- ```bash
- mega-evme replay --rpc --dump-fixture bench/replay/fixtures/.json
- ```
-
- The dump only writes if the local replay reproduces the on-chain receipt's gas
- and status, so the fixture is faithful by construction. For a non-on-chain
- workload, produce the same `TestUnit` shape by other means (see below).
-
-2. **Replay offline.** The driver times each fixture's isolated EVM `transact`
- call with `state-test --bench`, reporting `min`/`median`/`mean` and Mgas/s.
-
-3. **Compare.** With two binaries (base and PR) the driver interleaves them
- **ABBA** across several rounds so machine drift cancels, takes each binary's
- median, and reports Δ% per case. A case whose PR median is more than the
- threshold slower is flagged a regression.
-
-## Corpus
-
-`manifest.json` lists the bench cases — each chosen for a distinct workload shape
-(system-contract interception, plain compute, log-heavy metering, heavy
-multi-call, limit-tracker stress). Every case records `expected_gas`; the driver
-fails if a binary runs it with different gas (that would mean different work is
-being timed). A case names its `spec` explicitly only when its fixture carries an
-empty `post`; otherwise the spec is taken from the fixture's `post` key.
-
-The correctness test (`replay_corpus.rs`) globs `fixtures/` directly, so every
-fixture with a populated `post` is validated. `fixtures/attack_deploy.json` is a
-mainnet attack contract deployment (#299) converted from a `prestateTracer`
-snapshot — a non-on-chain, 142M-gas limit-tracker stress case; its `post` was
-filled offline with `state-test --fill`, so it too is validated and benched.
-
-## Running locally
-
-```bash
-cargo build --release -p mega-evme -p state-test
-
-# Measure the current build:
-python3 bench/replay/run.py --bin pr=target/release
-
-# Compare two builds (each --bin is a directory containing mega-evme + state-test,
-# or the path to mega-evme with state-test alongside it):
-python3 bench/replay/run.py \
- --bin base=/path/to/main/target/release \
- --bin pr=target/release \
- --rounds 7 --threshold-pct 7 --fail-on-regression
-```
-
-Useful flags: `--runs` / `--warmup`, `--rounds` (ABBA rounds), `--threshold-pct`,
-`--json-out` / `--markdown-out`, `--fail-on-regression`.
-
-## Adding a case
-
-For a **mined transaction**, dump it (step 1 above) into `fixtures/.json`,
-then add a `manifest.json` entry with `"type": "fixture"`, the `fixture` path,
-`expected_gas`, `category`, and a `note`.
-
-For a **non-on-chain workload** (an attack/edge case from a `prestateTracer`
-snapshot or a hand-crafted scenario), produce the `TestUnit` JSON directly
-(`env` + `pre` + `transaction` + an empty `post: {}`), then fill its `post` so it
-is validated too:
-
-```bash
-state-test --fill --bench-spec bench/replay/fixtures/.json
-```
-
-Add the `manifest.json` entry as above (no `spec` needed once `post` is filled).
-
-Both kinds end up with a populated `post`, so they are picked up by the per-PR
-correctness test automatically — no extra wiring.
-
-Verify with `python3 bench/replay/run.py --bin pr=target/release` (bench) and
-`cargo test -p mega-state-test --test replay_corpus` (correctness).
-
-> To benchmark a single transaction ad-hoc, dump it
-> (`mega-evme replay --dump-fixture /tmp/x.json `) and time it
-> (`state-test --bench /tmp/x.json`) — no manifest entry needed.
-
-## CI
-
-- **Correctness** runs on every PR: `cargo test` (`build-and-test.yml`) executes
- `replay_corpus.rs`, which validates the recorded post-state of every fixture.
-- **Performance** runs on demand: `replay-bench.yml` (weekly / manual dispatch /
- member `/replay-bench` PR comment) builds the PR and merge-base binaries,
- runs the driver, and posts the comparison table (job summary + PR comment).
-
-Timing on shared runners is noisy for sub-10µs cases; read the larger cases and
-the overall trend across the corpus for real signal.
diff --git a/bench/replay/fixtures/attack_deploy.json b/bench/replay/fixtures/attack_deploy.json
deleted file mode 100644
index 3bf39efc3..000000000
--- a/bench/replay/fixtures/attack_deploy.json
+++ /dev/null
@@ -1,151 +0,0 @@
-{
- "attack_deploy": {
- "_info": null,
- "env": {
- "currentChainID": "0x10e6",
- "currentCoinbase": "0x4200000000000000000000000000000000000011",
- "currentDifficulty": "0x0",
- "currentGasLimit": "0x2540be400",
- "currentNumber": "0xfda7da",
- "currentTimestamp": "0x6a0fcfad",
- "currentBaseFee": "0xf4240",
- "currentRandom": "0x9facac34967efd2bd06396afe5433cc0746ac1893c40f72f472204bbd025fd5a",
- "currentExcessBlobGas": "0x0"
- },
- "pre": {
- "0x0000000000000000000000000000000000000001": {
- "balance": "0xd8750d6ceef",
- "code": "0x",
- "nonce": "0x0",
- "storage": {}
- },
- "0x1c6100bfa8e67837ba9d13a7447c853e32728204": {
- "balance": "0x0",
- "code": "0x",
- "nonce": "0x0",
- "storage": {}
- },
- "0x355ac514807d5118ec8160e7b4bb2a108f7d74da": {
- "balance": "0x0",
- "code": "0x",
- "nonce": "0x0",
- "storage": {
- "0x0": "0x0",
- "0x1": "0x0",
- "0x2": "0x0",
- "0x3": "0x0",
- "0x4": "0x0"
- }
- },
- "0x4200000000000000000000000000000000000011": {
- "balance": "0x161526c2a4454d7a",
- "code": "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",
- "nonce": "0x0",
- "storage": {}
- },
- "0x4200000000000000000000000000000000000019": {
- "balance": "0x24786b4c6222b4540",
- "code": "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",
- "nonce": "0x0",
- "storage": {}
- },
- "0x420000000000000000000000000000000000001a": {
- "balance": "0x2da889885f77cbf",
- "code": "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",
- "nonce": "0x0",
- "storage": {}
- },
- "0x420000000000000000000000000000000000001b": {
- "balance": "0x0",
- "code": "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",
- "nonce": "0x0",
- "storage": {}
- },
- "0x578d8871249a0b9956542a60024a30306f747852": {
- "balance": "0x0",
- "code": "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",
- "nonce": "0x1",
- "storage": {
- "0x213b9ef722885121b6bf233baaf1feb2baa4e1c38e5a6bb52c2caba2878310d0": "0x0",
- "0x412b2a79ba55ab55c0b244056436f982b53c897ea723181bcc9526d610d16fec": "0x0",
- "0x5de41bfeea9b974a4c1153f1bbe02a33fd5b35f2f7fa3395a32f9b8d51611a25": "0x0",
- "0x5fca353663f6f9935bf2a9a8fe1d01e70ed429ffb39a1e8e2a5e8c9bee308eb5": "0x0",
- "0x9c9b00837f0d78bb3c52145f309fe3a14fa68532cb2c348fca275ba98bf24f12": "0x0",
- "0xafd34d6b52de283969cab1deb3a652d8c16a9f10b3260769521e40fbc87cffe2": "0x0",
- "0xc66533f103d34d4c87a84143199cf05b541308f878c7ee0224a302a19961e71c": "0x33b2e3c9fd0803ce8000000",
- "0xc6c74f62bfa1cb8d48cede291887c0d1cb390939ec5512846ef312ac741eae2a": "0x0",
- "0xc80bbbf4eec8fdcb43a21dd2f2ba3ec0060e478e7e2466e4698ba3dd301ee16c": "0x0",
- "0xdbc7913112c06ca7601ac55969b95e2c3ace896ce372ddfb11236d7973e35b00": "0x0"
- }
- },
- "0x632b7da5ea5912330ed23af39d09e457294168ee": {
- "balance": "0x0",
- "code": "0x",
- "nonce": "0x0",
- "storage": {
- "0x0": "0x0",
- "0x1": "0x0",
- "0x2": "0x0"
- }
- },
- "0xd4c1ecfc39ad51ab8ecdd0240a27dadd363b4739": {
- "balance": "0x0",
- "code": "0x",
- "nonce": "0x0",
- "storage": {
- "0x1": "0x0",
- "0x5de41bfeea9b974a4c1153f1bbe02a33fd5b35f2f7fa3395a32f9b8d51611a25": "0x0",
- "0xc80bbbf4eec8fdcb43a21dd2f2ba3ec0060e478e7e2466e4698ba3dd301ee16c": "0x0"
- }
- },
- "0xfb0de6ab3cd3aeee1b3abeb51ee3b98d576e929b": {
- "balance": "0x89dbbd283b4d9",
- "code": "0x",
- "nonce": "0x5",
- "storage": {}
- }
- },
- "post": {
- "Rex5": [
- {
- "indexes": {
- "data": 0,
- "gas": 0,
- "value": 0
- },
- "hash": "0x88c7f86774c0fdd60dfe6d3fbb89ac3147b9da909726dd37096436695111bd52",
- "logs": "0x8520535971d35c7f4b16759e777438a30e53ca1ba223355342ae2bbf642da118",
- "megaGasUsed": 141927106,
- "megaStatus": "success"
- }
- ]
- },
- "transaction": {
- "type": 2,
- "data": [
- "0x608060405234801561000f575f5ffd5b5060405161432638038061432683398181016040528101906100319190610723565b5f73ffffffffffffffffffffffffffffffffffffffff168673ffffffffffffffffffffffffffffffffffffffff160361009f576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100969061082e565b60405180910390fd5b600a8710156100e3576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100da906108bc565b60405180910390fd5b5f600a886100f19190610934565b90505f8990505f828a6101049190610964565b90508a73ffffffffffffffffffffffffffffffffffffffff1663d505accf89307fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff8b8b8b8b6040518863ffffffff1660e01b815260040161016b97969594939291906109d3565b5f604051808303815f87803b158015610182575f5ffd5b505af1158015610194573d5f5f3e3d5ffd5b505050508173ffffffffffffffffffffffffffffffffffffffff166323b872dd8930846040518463ffffffff1660e01b81526004016101d593929190610a40565b6020604051808303815f875af11580156101f1573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906102159190610aaa565b508a60405161022390610602565b61022d9190610ad5565b604051809103905ff080158015610246573d5f5f3e3d5ffd5b505f5f6101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055508173ffffffffffffffffffffffffffffffffffffffff1663095ea7b35f5f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff168c6040518363ffffffff1660e01b81526004016102e0929190610aee565b6020604051808303815f875af11580156102fc573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906103209190610aaa565b505f5f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1663b6b55f258b6040518263ffffffff1660e01b815260040161037a9190610b15565b5f604051808303815f87803b158015610391575f5ffd5b505af11580156103a3573d5f5f3e3d5ffd5b505050508a6040516103b49061060f565b6103be9190610ad5565b604051809103905ff0801580156103d7573d5f5f3e3d5ffd5b5060015f6101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055508173ffffffffffffffffffffffffffffffffffffffff1663a9059cbb60015f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff16856040518363ffffffff1660e01b8152600401610473929190610aee565b6020604051808303815f875af115801561048f573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906104b39190610aaa565b505f5f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff168b6040516104e29061061c565b6104ed929190610b2e565b604051809103905ff080158015610506573d5f5f3e3d5ffd5b5060025f6101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555060025f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff166388a8aec660015f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff16858c6040518463ffffffff1660e01b81526004016105c593929190610b55565b5f604051808303815f87803b1580156105dc575f5ffd5b505af11580156105ee573d5f5f3e3d5ffd5b505050505050505050505050505050610b8a565b610c3c80610ddd83390190565b610d4280611a1983390190565b611bcb8061275b83390190565b5f5ffd5b5f73ffffffffffffffffffffffffffffffffffffffff82169050919050565b5f6106568261062d565b9050919050565b6106668161064c565b8114610670575f5ffd5b50565b5f815190506106818161065d565b92915050565b5f819050919050565b61069981610687565b81146106a3575f5ffd5b50565b5f815190506106b481610690565b92915050565b5f60ff82169050919050565b6106cf816106ba565b81146106d9575f5ffd5b50565b5f815190506106ea816106c6565b92915050565b5f819050919050565b610702816106f0565b811461070c575f5ffd5b50565b5f8151905061071d816106f9565b92915050565b5f5f5f5f5f5f5f5f610100898b0312156107405761073f610629565b5b5f61074d8b828c01610673565b985050602061075e8b828c016106a6565b975050604061076f8b828c01610673565b96505060606107808b828c01610673565b95505060806107918b828c016106a6565b94505060a06107a28b828c016106dc565b93505060c06107b38b828c0161070f565b92505060e06107c48b828c0161070f565b9150509295985092959890939650565b5f82825260208201905092915050565b7f4578706c6f697453657475703a207a65726f20726563656976657200000000005f82015250565b5f610818601b836107d4565b9150610823826107e4565b602082019050919050565b5f6020820190508181035f8301526108458161080c565b9050919050565b7f4578706c6f697453657475703a2073656564416d6f756e7420746f6f20736d615f8201527f6c6c000000000000000000000000000000000000000000000000000000000000602082015250565b5f6108a66022836107d4565b91506108b18261084c565b604082019050919050565b5f6020820190508181035f8301526108d38161089a565b9050919050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601260045260245ffd5b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b5f61093e82610687565b915061094983610687565b925082610959576109586108da565b5b828204905092915050565b5f61096e82610687565b915061097983610687565b925082820190508082111561099157610990610907565b5b92915050565b6109a08161064c565b82525050565b6109af81610687565b82525050565b6109be816106ba565b82525050565b6109cd816106f0565b82525050565b5f60e0820190506109e65f83018a610997565b6109f36020830189610997565b610a0060408301886109a6565b610a0d60608301876109a6565b610a1a60808301866109b5565b610a2760a08301856109c4565b610a3460c08301846109c4565b98975050505050505050565b5f606082019050610a535f830186610997565b610a606020830185610997565b610a6d60408301846109a6565b949350505050565b5f8115159050919050565b610a8981610a75565b8114610a93575f5ffd5b50565b5f81519050610aa481610a80565b92915050565b5f60208284031215610abf57610abe610629565b5b5f610acc84828501610a96565b91505092915050565b5f602082019050610ae85f830184610997565b92915050565b5f604082019050610b015f830185610997565b610b0e60208301846109a6565b9392505050565b5f602082019050610b285f8301846109a6565b92915050565b5f604082019050610b415f830185610997565b610b4e6020830184610997565b9392505050565b5f606082019050610b685f830186610997565b610b7560208301856109a6565b610b826040830184610997565b949350505050565b61024680610b975f395ff3fe608060405234801561000f575f5ffd5b506004361061003f575f3560e01c806348eb76ee14610043578063bcead63e14610061578063fbfa77cf1461007f575b5f5ffd5b61004b61009d565b6040516100589190610185565b60405180910390f35b6100696100c2565b60405161007691906101be565b60405180910390f35b6100876100e7565b60405161009491906101f7565b60405180910390f35b60025f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b60015f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b5f5f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b5f73ffffffffffffffffffffffffffffffffffffffff82169050919050565b5f819050919050565b5f61014d6101486101438461010b565b61012a565b61010b565b9050919050565b5f61015e82610133565b9050919050565b5f61016f82610154565b9050919050565b61017f81610165565b82525050565b5f6020820190506101985f830184610176565b92915050565b5f6101a882610154565b9050919050565b6101b88161019e565b82525050565b5f6020820190506101d15f8301846101af565b92915050565b5f6101e182610154565b9050919050565b6101f1816101d7565b82525050565b5f60208201905061020a5f8301846101e8565b9291505056fea2646970667358221220ab8ca3bad83057bc6502e4d5e818ec45197087ada5dff4a28bd506a700a0182364736f6c634300081e003360a060405234801561000f575f5ffd5b50604051610c3c380380610c3c833981810160405281019061003191906100c9565b8073ffffffffffffffffffffffffffffffffffffffff1660808173ffffffffffffffffffffffffffffffffffffffff1681525050506100f4565b5f5ffd5b5f73ffffffffffffffffffffffffffffffffffffffff82169050919050565b5f6100988261006f565b9050919050565b6100a88161008e565b81146100b2575f5ffd5b50565b5f815190506100c38161009f565b92915050565b5f602082840312156100de576100dd61006b565b5b5f6100eb848285016100b5565b91505092915050565b608051610b1b6101215f395f81816101b20152818161039b0152818161044a01526105ba0152610b1b5ff3fe608060405234801561000f575f5ffd5b506004361061005f575f3560e01c8062f714ce1461006357806301e1d1141461007f5780633a98ef391461009d578063b6b55f25146100bb578063ce7c2ac2146100d7578063fc0c546a14610107575b5f5ffd5b61007d600480360381019061007891906106cf565b610125565b005b610087610398565b604051610094919061071c565b60405180910390f35b6100a5610436565b6040516100b2919061071c565b60405180910390f35b6100d560048036038101906100d09190610735565b61043c565b005b6100f160048036038101906100ec9190610760565b6105a4565b6040516100fe919061071c565b60405180910390f35b61010f6105b8565b60405161011c91906107e6565b60405180910390f35b815f5f3373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f205410156101a4576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161019b9061087f565b60405180910390fd5b5f6101ae836105dc565b90507f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff1663a9059cbb83836040518363ffffffff1660e01b815260040161020b9291906108ac565b6020604051808303815f875af1158015610227573d5f5f3e3d5ffd5b505050506040513d601f19601f8201168201806040525081019061024b9190610908565b505f8273ffffffffffffffffffffffffffffffffffffffff163b11156102d4578173ffffffffffffffffffffffffffffffffffffffff16633531bb2833836040518363ffffffff1660e01b81526004016102a69291906108ac565b5f604051808303815f87803b1580156102bd575f5ffd5b505af11580156102cf573d5f5f3e3d5ffd5b505050505b825f5f3373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f205f82825403925050819055508260015f82825403925050819055508173ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff167ff341246adaac6f497bc2a656f546ab9e182111d630394f0c57c710a59a2cb567838660405161038b929190610933565b60405180910390a3505050565b5f7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff166370a08231306040518263ffffffff1660e01b81526004016103f2919061095a565b602060405180830381865afa15801561040d573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906104319190610987565b905090565b60015481565b5f61044682610604565b90507f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff166323b872dd3330856040518463ffffffff1660e01b81526004016104a5939291906109b2565b6020604051808303815f875af11580156104c1573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906104e59190610908565b50805f5f3373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f205f8282546105319190610a14565b925050819055508060015f8282546105499190610a14565b925050819055503373ffffffffffffffffffffffffffffffffffffffff167f90890809c654f11d6e72a28fa60149770a0d11ec6c92319d6ceb2bb0a4ea1a158383604051610598929190610933565b60405180910390a25050565b5f602052805f5260405f205f915090505481565b7f000000000000000000000000000000000000000000000000000000000000000081565b5f6001546105e8610398565b836105f39190610a47565b6105fd9190610ab5565b9050919050565b5f5f6001540361061657819050610639565b61061e610398565b6001548361062c9190610a47565b6106369190610ab5565b90505b919050565b5f5ffd5b5f819050919050565b61065481610642565b811461065e575f5ffd5b50565b5f8135905061066f8161064b565b92915050565b5f73ffffffffffffffffffffffffffffffffffffffff82169050919050565b5f61069e82610675565b9050919050565b6106ae81610694565b81146106b8575f5ffd5b50565b5f813590506106c9816106a5565b92915050565b5f5f604083850312156106e5576106e461063e565b5b5f6106f285828601610661565b9250506020610703858286016106bb565b9150509250929050565b61071681610642565b82525050565b5f60208201905061072f5f83018461070d565b92915050565b5f6020828403121561074a5761074961063e565b5b5f61075784828501610661565b91505092915050565b5f602082840312156107755761077461063e565b5b5f610782848285016106bb565b91505092915050565b5f819050919050565b5f6107ae6107a96107a484610675565b61078b565b610675565b9050919050565b5f6107bf82610794565b9050919050565b5f6107d0826107b5565b9050919050565b6107e0816107c6565b82525050565b5f6020820190506107f95f8301846107d7565b92915050565b5f82825260208201905092915050565b7f56756c6e657261626c655661756c743a20696e73756666696369656e742073685f8201527f6172657300000000000000000000000000000000000000000000000000000000602082015250565b5f6108696024836107ff565b91506108748261080f565b604082019050919050565b5f6020820190508181035f8301526108968161085d565b9050919050565b6108a681610694565b82525050565b5f6040820190506108bf5f83018561089d565b6108cc602083018461070d565b9392505050565b5f8115159050919050565b6108e7816108d3565b81146108f1575f5ffd5b50565b5f81519050610902816108de565b92915050565b5f6020828403121561091d5761091c61063e565b5b5f61092a848285016108f4565b91505092915050565b5f6040820190506109465f83018561070d565b610953602083018461070d565b9392505050565b5f60208201905061096d5f83018461089d565b92915050565b5f815190506109818161064b565b92915050565b5f6020828403121561099c5761099b61063e565b5b5f6109a984828501610973565b91505092915050565b5f6060820190506109c55f83018661089d565b6109d2602083018561089d565b6109df604083018461070d565b949350505050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b5f610a1e82610642565b9150610a2983610642565b9250828201905080821115610a4157610a406109e7565b5b92915050565b5f610a5182610642565b9150610a5c83610642565b9250828202610a6a81610642565b91508282048414831517610a8157610a806109e7565b5b5092915050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601260045260245ffd5b5f610abf82610642565b9150610aca83610642565b925082610ada57610ad9610a88565b5b82820490509291505056fea26469706673582212202a8c0a6b9c40bfa0255196a7ac23db2258484ca87e3a6a9d5a996a2ff8383b1264736f6c634300081e003360a060405234801561000f575f5ffd5b50604051610d42380380610d42833981810160405281019061003191906100c9565b8073ffffffffffffffffffffffffffffffffffffffff1660808173ffffffffffffffffffffffffffffffffffffffff1681525050506100f4565b5f5ffd5b5f73ffffffffffffffffffffffffffffffffffffffff82169050919050565b5f6100988261006f565b9050919050565b6100a88161008e565b81146100b2575f5ffd5b50565b5f815190506100c38161009f565b92915050565b5f602082840312156100de576100dd61006b565b5b5f6100eb848285016100b5565b91505092915050565b608051610c0d6101355f395f818160c7015281816101a70152818161028101528181610338015281816103f00152818161046e01526105a30152610c0d5ff3fe608060405234801561000f575f5ffd5b506004361061004a575f3560e01c806315770f921461004e5780635296a4311461006c578063bf333f2c14610088578063fc0c546a146100a6575b5f5ffd5b6100566100c4565b60405161006391906105dd565b60405180910390f35b61008660048036038101906100819190610689565b610162565b005b61009061059c565b60405161009d91906105dd565b60405180910390f35b6100ae6105a1565b6040516100bb9190610760565b60405180910390f35b5f7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff166370a08231306040518263ffffffff1660e01b815260040161011e9190610799565b602060405180830381865afa158015610139573d5f5f3e3d5ffd5b505050506040513d601f19601f8201168201806040525081019061015d91906107c6565b905090565b5f83116101a4576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161019b9061084b565b60405180910390fd5b827f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff166370a08231306040518263ffffffff1660e01b81526004016101fe9190610799565b602060405180830381865afa158015610219573d5f5f3e3d5ffd5b505050506040513d601f19601f8201168201806040525081019061023d91906107c6565b101561027e576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610275906108d9565b60405180910390fd5b5f7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff166370a08231306040518263ffffffff1660e01b81526004016102d89190610799565b602060405180830381865afa1580156102f3573d5f5f3e3d5ffd5b505050506040513d601f19601f8201168201806040525081019061031791906107c6565b90505f612710600a8661032a9190610924565b6103349190610992565b90507f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff1663a9059cbb33876040518363ffffffff1660e01b81526004016103919291906109c2565b6020604051808303815f875af11580156103ad573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906103d19190610a1e565b503373ffffffffffffffffffffffffffffffffffffffff1663ee8725587f0000000000000000000000000000000000000000000000000000000000000000878488886040518663ffffffff1660e01b8152600401610433959493929190610aa3565b5f604051808303815f87803b15801561044a575f5ffd5b505af115801561045c573d5f5f3e3d5ffd5b50505050808261046c9190610aef565b7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff166370a08231306040518263ffffffff1660e01b81526004016104c59190610799565b602060405180830381865afa1580156104e0573d5f5f3e3d5ffd5b505050506040513d601f19601f8201168201806040525081019061050491906107c6565b1015610545576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161053c90610b92565b60405180910390fd5b3373ffffffffffffffffffffffffffffffffffffffff167f31aaad38f00845a242d16ae90d7bd72fc68f0e22581470f9dc0de241210c2886868360405161058d929190610bb0565b60405180910390a25050505050565b600a81565b7f000000000000000000000000000000000000000000000000000000000000000081565b5f819050919050565b6105d7816105c5565b82525050565b5f6020820190506105f05f8301846105ce565b92915050565b5f5ffd5b5f5ffd5b610607816105c5565b8114610611575f5ffd5b50565b5f81359050610622816105fe565b92915050565b5f5ffd5b5f5ffd5b5f5ffd5b5f5f83601f84011261064957610648610628565b5b8235905067ffffffffffffffff8111156106665761066561062c565b5b60208301915083600182028301111561068257610681610630565b5b9250929050565b5f5f5f604084860312156106a05761069f6105f6565b5b5f6106ad86828701610614565b935050602084013567ffffffffffffffff8111156106ce576106cd6105fa565b5b6106da86828701610634565b92509250509250925092565b5f73ffffffffffffffffffffffffffffffffffffffff82169050919050565b5f819050919050565b5f61072861072361071e846106e6565b610705565b6106e6565b9050919050565b5f6107398261070e565b9050919050565b5f61074a8261072f565b9050919050565b61075a81610740565b82525050565b5f6020820190506107735f830184610751565b92915050565b5f610783826106e6565b9050919050565b61079381610779565b82525050565b5f6020820190506107ac5f83018461078a565b92915050565b5f815190506107c0816105fe565b92915050565b5f602082840312156107db576107da6105f6565b5b5f6107e8848285016107b2565b91505092915050565b5f82825260208201905092915050565b7f466c6173684c6f616e50726f76696465723a207a65726f20616d6f756e7400005f82015250565b5f610835601e836107f1565b915061084082610801565b602082019050919050565b5f6020820190508181035f83015261086281610829565b9050919050565b7f466c6173684c6f616e50726f76696465723a20696e73756666696369656e74205f8201527f6c69717569646974790000000000000000000000000000000000000000000000602082015250565b5f6108c36029836107f1565b91506108ce82610869565b604082019050919050565b5f6020820190508181035f8301526108f0816108b7565b9050919050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b5f61092e826105c5565b9150610939836105c5565b9250828202610947816105c5565b9150828204841483151761095e5761095d6108f7565b5b5092915050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601260045260245ffd5b5f61099c826105c5565b91506109a7836105c5565b9250826109b7576109b6610965565b5b828204905092915050565b5f6040820190506109d55f83018561078a565b6109e260208301846105ce565b9392505050565b5f8115159050919050565b6109fd816109e9565b8114610a07575f5ffd5b50565b5f81519050610a18816109f4565b92915050565b5f60208284031215610a3357610a326105f6565b5b5f610a4084828501610a0a565b91505092915050565b5f82825260208201905092915050565b828183375f83830152505050565b5f601f19601f8301169050919050565b5f610a828385610a49565b9350610a8f838584610a59565b610a9883610a67565b840190509392505050565b5f608082019050610ab65f83018861078a565b610ac360208301876105ce565b610ad060408301866105ce565b8181036060830152610ae3818486610a77565b90509695505050505050565b5f610af9826105c5565b9150610b04836105c5565b9250828201905080821115610b1c57610b1b6108f7565b5b92915050565b7f466c6173684c6f616e50726f76696465723a2072657061796d656e74206661695f8201527f6c65640000000000000000000000000000000000000000000000000000000000602082015250565b5f610b7c6023836107f1565b9150610b8782610b22565b604082019050919050565b5f6020820190508181035f830152610ba981610b70565b9050919050565b5f604082019050610bc35f8301856105ce565b610bd060208301846105ce565b939250505056fea26469706673582212206691e76a4659ab3c827b6e86570c1be41fc2a147f0025be0326de7283c36b97e64736f6c634300081e003360c060405234801561000f575f5ffd5b50604051611bcb380380611bcb833981810160405281019061003191906100fe565b8173ffffffffffffffffffffffffffffffffffffffff1660808173ffffffffffffffffffffffffffffffffffffffff16815250508073ffffffffffffffffffffffffffffffffffffffff1660a08173ffffffffffffffffffffffffffffffffffffffff1681525050505061013c565b5f5ffd5b5f73ffffffffffffffffffffffffffffffffffffffff82169050919050565b5f6100cd826100a4565b9050919050565b6100dd816100c3565b81146100e7575f5ffd5b50565b5f815190506100f8816100d4565b92915050565b5f5f60408385031215610114576101136100a0565b5b5f610121858286016100ea565b9250506020610132858286016100ea565b9150509250929050565b60805160a0516119e96101e25f395f818161014a015281816102260152818161047001528181610731015281816109f301528181610ac401528181610c5601528181610ef701528181610fd601526110a701525f81816102c601528181610394015281816104ac0152818161052c015281816105b20152818161066f01528181610c9201528181610d1201528181610d9801528181610e55015261108301526119e95ff3fe608060405234801561000f575f5ffd5b506004361061007b575f3560e01c806388a8aec61161005957806388a8aec6146100d3578063ee872558146100ef578063fbfa77cf1461010b578063fc0c546a146101295761007b565b806327a7833f1461007f5780633531bb281461009b57806364dd891a146100b7575b5f5ffd5b6100996004803603810190610094919061112b565b610147565b005b6100b560048036038101906100b09190611189565b6102c4565b005b6100d160048036038101906100cc91906111c7565b61041f565b005b6100ed60048036038101906100e891906111f2565b6107df565b005b610109600480360381019061010491906112a3565b610b64565b005b610113611081565b6040516101209190611382565b60405180910390f35b6101316110a5565b60405161013e91906113bb565b60405180910390f35b5f7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff166370a08231306040518263ffffffff1660e01b81526004016101a191906113e3565b602060405180830381865afa1580156101bc573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906101e09190611410565b90505f8111610224576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161021b90611495565b60405180910390fd5b7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff1663a9059cbb83836040518363ffffffff1660e01b815260040161027f9291906114c2565b6020604051808303815f875af115801561029b573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906102bf919061151e565b505050565b7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff1614610352576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161034990611593565b60405180910390fd5b60015f9054906101000a900460ff16158061036c57505f81145b61041b576064600254101561041b5760025f81548092919061038d906115de565b91905055507f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff1662f714ce5f54306040518363ffffffff1660e01b81526004016103ed929190611625565b5f604051808303815f87803b158015610404575f5ffd5b505af1158015610416573d5f5f3e3d5ffd5b505050505b5050565b60015f9054906101000a900460ff161561046e576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161046590611696565b60405180910390fd5b7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff1663095ea7b37f0000000000000000000000000000000000000000000000000000000000000000836040518363ffffffff1660e01b81526004016104e99291906114c2565b6020604051808303815f875af1158015610505573d5f5f3e3d5ffd5b505050506040513d601f19601f82011682018060405250810190610529919061151e565b507f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff1663b6b55f25826040518263ffffffff1660e01b815260040161058391906116b4565b5f604051808303815f87803b15801561059a575f5ffd5b505af11580156105ac573d5f5f3e3d5ffd5b505050507f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff1663ce7c2ac2306040518263ffffffff1660e01b815260040161060991906113e3565b602060405180830381865afa158015610624573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906106489190611410565b5f819055505f6002819055506001805f6101000a81548160ff0219169083151502179055507f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff1662f714ce5f54306040518363ffffffff1660e01b81526004016106c8929190611625565b5f604051808303815f87803b1580156106df575f5ffd5b505af11580156106f1573d5f5f3e3d5ffd5b505050505f60015f6101000a81548160ff0219169083151502179055507f45776e8c4137c2d25b59c6bc4e32fd07c3789be92c2623f548bdcc1c513ffad67f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff166370a08231306040518263ffffffff1660e01b815260040161078891906113e3565b602060405180830381865afa1580156107a3573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906107c79190611410565b6040516107d491906116b4565b60405180910390a150565b60015f9054906101000a900460ff161561082e576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161082590611696565b60405180910390fd5b5f73ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff160361089c576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161089390611717565b60405180910390fd5b5f73ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff160361090a576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016109019061177f565b60405180910390fd5b8260035f6101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055508273ffffffffffffffffffffffffffffffffffffffff16635296a431836040518263ffffffff1660e01b815260040161098391906117d0565b5f604051808303815f87803b15801561099a575f5ffd5b505af11580156109ac573d5f5f3e3d5ffd5b505050505f60035f6101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055505f7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff166370a08231306040518263ffffffff1660e01b8152600401610a4a91906113e3565b602060405180830381865afa158015610a65573d5f5f3e3d5ffd5b505050506040513d601f19601f82011682018060405250810190610a899190611410565b90507f45776e8c4137c2d25b59c6bc4e32fd07c3789be92c2623f548bdcc1c513ffad681604051610aba91906116b4565b60405180910390a17f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff1663a9059cbb83836040518363ffffffff1660e01b8152600401610b1d9291906114c2565b6020604051808303815f875af1158015610b39573d5f5f3e3d5ffd5b505050506040513d601f19601f82011682018060405250810190610b5d919061151e565b5050505050565b60035f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff1614610bf3576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610bea9061186c565b60405180910390fd5b60015f9054906101000a900460ff1615610c42576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610c39906118d4565b60405180910390fd5b8284610c4e91906118f2565b6004819055507f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff1663095ea7b37f0000000000000000000000000000000000000000000000000000000000000000866040518363ffffffff1660e01b8152600401610ccf9291906114c2565b6020604051808303815f875af1158015610ceb573d5f5f3e3d5ffd5b505050506040513d601f19601f82011682018060405250810190610d0f919061151e565b507f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff1663b6b55f25856040518263ffffffff1660e01b8152600401610d6991906116b4565b5f604051808303815f87803b158015610d80575f5ffd5b505af1158015610d92573d5f5f3e3d5ffd5b505050507f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff1663ce7c2ac2306040518263ffffffff1660e01b8152600401610def91906113e3565b602060405180830381865afa158015610e0a573d5f5f3e3d5ffd5b505050506040513d601f19601f82011682018060405250810190610e2e9190611410565b5f819055505f6002819055506001805f6101000a81548160ff0219169083151502179055507f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff1662f714ce5f54306040518363ffffffff1660e01b8152600401610eae929190611625565b5f604051808303815f87803b158015610ec5575f5ffd5b505af1158015610ed7573d5f5f3e3d5ffd5b505050505f60015f6101000a81548160ff0219169083151502179055505f7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff166370a08231306040518263ffffffff1660e01b8152600401610f4e91906113e3565b602060405180830381865afa158015610f69573d5f5f3e3d5ffd5b505050506040513d601f19601f82011682018060405250810190610f8d9190611410565b9050600454811015610fd4576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610fcb90611995565b60405180910390fd5b7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff1663a9059cbb336004546040518363ffffffff1660e01b81526004016110319291906114c2565b6020604051808303815f875af115801561104d573d5f5f3e3d5ffd5b505050506040513d601f19601f82011682018060405250810190611071919061151e565b505f600481905550505050505050565b7f000000000000000000000000000000000000000000000000000000000000000081565b7f000000000000000000000000000000000000000000000000000000000000000081565b5f5ffd5b5f5ffd5b5f73ffffffffffffffffffffffffffffffffffffffff82169050919050565b5f6110fa826110d1565b9050919050565b61110a816110f0565b8114611114575f5ffd5b50565b5f8135905061112581611101565b92915050565b5f602082840312156111405761113f6110c9565b5b5f61114d84828501611117565b91505092915050565b5f819050919050565b61116881611156565b8114611172575f5ffd5b50565b5f813590506111838161115f565b92915050565b5f5f6040838503121561119f5761119e6110c9565b5b5f6111ac85828601611117565b92505060206111bd85828601611175565b9150509250929050565b5f602082840312156111dc576111db6110c9565b5b5f6111e984828501611175565b91505092915050565b5f5f5f60608486031215611209576112086110c9565b5b5f61121686828701611117565b935050602061122786828701611175565b925050604061123886828701611117565b9150509250925092565b5f5ffd5b5f5ffd5b5f5ffd5b5f5f83601f84011261126357611262611242565b5b8235905067ffffffffffffffff8111156112805761127f611246565b5b60208301915083600182028301111561129c5761129b61124a565b5b9250929050565b5f5f5f5f5f608086880312156112bc576112bb6110c9565b5b5f6112c988828901611117565b95505060206112da88828901611175565b94505060406112eb88828901611175565b935050606086013567ffffffffffffffff81111561130c5761130b6110cd565b5b6113188882890161124e565b92509250509295509295909350565b5f819050919050565b5f61134a611345611340846110d1565b611327565b6110d1565b9050919050565b5f61135b82611330565b9050919050565b5f61136c82611351565b9050919050565b61137c81611362565b82525050565b5f6020820190506113955f830184611373565b92915050565b5f6113a582611351565b9050919050565b6113b58161139b565b82525050565b5f6020820190506113ce5f8301846113ac565b92915050565b6113dd816110f0565b82525050565b5f6020820190506113f65f8301846113d4565b92915050565b5f8151905061140a8161115f565b92915050565b5f60208284031215611425576114246110c9565b5b5f611432848285016113fc565b91505092915050565b5f82825260208201905092915050565b7f41747461636b65725661756c743a206e6f2070726f66697400000000000000005f82015250565b5f61147f60188361143b565b915061148a8261144b565b602082019050919050565b5f6020820190508181035f8301526114ac81611473565b9050919050565b6114bc81611156565b82525050565b5f6040820190506114d55f8301856113d4565b6114e260208301846114b3565b9392505050565b5f8115159050919050565b6114fd816114e9565b8114611507575f5ffd5b50565b5f81519050611518816114f4565b92915050565b5f60208284031215611533576115326110c9565b5b5f6115408482850161150a565b91505092915050565b7f41747461636b65725661756c743a20756e747275737465642063616c6c6572005f82015250565b5f61157d601f8361143b565b915061158882611549565b602082019050919050565b5f6020820190508181035f8301526115aa81611571565b9050919050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b5f6115e882611156565b91507fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff820361161a576116196115b1565b5b600182019050919050565b5f6040820190506116385f8301856114b3565b61164560208301846113d4565b9392505050565b7f616c72656164792061747461636b696e670000000000000000000000000000005f82015250565b5f61168060118361143b565b915061168b8261164c565b602082019050919050565b5f6020820190508181035f8301526116ad81611674565b9050919050565b5f6020820190506116c75f8301846114b3565b92915050565b7f41747461636b65725661756c743a207a65726f2070726f7669646572000000005f82015250565b5f611701601c8361143b565b915061170c826116cd565b602082019050919050565b5f6020820190508181035f83015261172e816116f5565b9050919050565b7f41747461636b65725661756c743a207a65726f207265636569766572000000005f82015250565b5f611769601c8361143b565b915061177482611735565b602082019050919050565b5f6020820190508181035f8301526117968161175d565b9050919050565b5f82825260208201905092915050565b50565b5f6117bb5f8361179d565b91506117c6826117ad565b5f82019050919050565b5f6040820190506117e35f8301846114b3565b81810360208301526117f4816117b0565b905092915050565b7f41747461636b65725661756c743a20756e7472757374656420666c617368206c5f8201527f6f616e2063616c6c657200000000000000000000000000000000000000000000602082015250565b5f611856602a8361143b565b9150611861826117fc565b604082019050919050565b5f6020820190508181035f8301526118838161184a565b9050919050565b7f41747461636b65725661756c743a20616c72656164792061747461636b696e675f82015250565b5f6118be60208361143b565b91506118c98261188a565b602082019050919050565b5f6020820190508181035f8301526118eb816118b2565b9050919050565b5f6118fc82611156565b915061190783611156565b925082820190508082111561191f5761191e6115b1565b5b92915050565b7f41747461636b65725661756c743a20696e73756666696369656e742070726f665f8201527f697420746f20726570617920666c617368206c6f616e00000000000000000000602082015250565b5f61197f60368361143b565b915061198a82611925565b604082019050919050565b5f6020820190508181035f8301526119ac81611973565b905091905056fea2646970667358221220fc1f514f8b97ef8f8315bfe00f89ae09b20c0d1dcb5cae7ddb997ba15b28585364736f6c634300081e0033000000000000000000000000578d8871249a0b9956542a60024a30306f74785200000000000000000000000000000000000000000000152d02c7e14af6800000000000000000000000000000b376fb62b70b26530ec271aadd6fcd046c5ee680000000000000000000000000fb0de6ab3cd3aeee1b3abeb51ee3b98d576e929bffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff000000000000000000000000000000000000000000000000000000000000001c0fd5bab052786547f33569ce66da6a5c5d53de3e080540a8296c7d2cc49f082c37cbe2d20bc2dcddec5b2794549c4e322f95cd25a30af781c226530b68d2e55d"
- ],
- "gasLimit": [
- "0x47868c00"
- ],
- "gasPrice": null,
- "nonce": "0x5",
- "secretKey": "0x0000000000000000000000000000000000000000000000000000000000000000",
- "sender": "0xfb0de6ab3cd3aeee1b3abeb51ee3b98d576e929b",
- "to": "",
- "value": [
- "0x0"
- ],
- "maxFeePerGas": "0x1e8480",
- "maxPriorityFeePerGas": "0xf4240",
- "initcodes": null,
- "accessLists": [
- null
- ],
- "authorizationList": null,
- "blobVersionedHashes": [],
- "maxFeePerBlobGas": null
- },
- "out": "0x608060405234801561000f575f5ffd5b506004361061003f575f3560e01c806348eb76ee14610043578063bcead63e14610061578063fbfa77cf1461007f575b5f5ffd5b61004b61009d565b6040516100589190610185565b60405180910390f35b6100696100c2565b60405161007691906101be565b60405180910390f35b6100876100e7565b60405161009491906101f7565b60405180910390f35b60025f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b60015f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b5f5f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b5f73ffffffffffffffffffffffffffffffffffffffff82169050919050565b5f819050919050565b5f61014d6101486101438461010b565b61012a565b61010b565b9050919050565b5f61015e82610133565b9050919050565b5f61016f82610154565b9050919050565b61017f81610165565b82525050565b5f6020820190506101985f830184610176565b92915050565b5f6101a882610154565b9050919050565b6101b88161019e565b82525050565b5f6020820190506101d15f8301846101af565b92915050565b5f6101e182610154565b9050919050565b6101f1816101d7565b82525050565b5f60208201905061020a5f8301846101e8565b9291505056fea2646970667358221220ab8ca3bad83057bc6502e4d5e818ec45197087ada5dff4a28bd506a700a0182364736f6c634300081e0033"
- }
-}
\ No newline at end of file
diff --git a/bench/replay/fixtures/large_defi.json b/bench/replay/fixtures/large_defi.json
deleted file mode 100644
index 56afae056..000000000
--- a/bench/replay/fixtures/large_defi.json
+++ /dev/null
@@ -1,119 +0,0 @@
-{
- "replay_0xb9fb1e85540f9f63e9bbc2c365cb4ed84ecfb6bf23ad39705ee2947d3d2179d6": {
- "_info": null,
- "env": {
- "currentChainID": "0x10e6",
- "currentCoinbase": "0x4200000000000000000000000000000000000011",
- "currentDifficulty": "0x0",
- "currentGasLimit": "0x2540be400",
- "currentNumber": "0x11557ee",
- "currentTimestamp": "0x6a277dc1",
- "currentBaseFee": "0xf4240",
- "currentRandom": "0x257b1f30cba44be7941133b715be042b3e078c096663493d671e6606001cfe73",
- "currentExcessBlobGas": "0x0"
- },
- "pre": {
- "0x0000000000000000000000000000000000000001": {
- "balance": "0xd8750d6ceef",
- "code": "0x",
- "nonce": "0x0",
- "storage": {}
- },
- "0x4200000000000000000000000000000000000011": {
- "balance": "0x5146dc51c366b4ed",
- "code": "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",
- "nonce": "0x0",
- "storage": {}
- },
- "0x4200000000000000000000000000000000000019": {
- "balance": "0x3043298c38a2aba00",
- "code": "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",
- "nonce": "0x0",
- "storage": {}
- },
- "0x420000000000000000000000000000000000001a": {
- "balance": "0x38dfb8842bc30b0",
- "code": "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",
- "nonce": "0x0",
- "storage": {}
- },
- "0x420000000000000000000000000000000000001b": {
- "balance": "0x0",
- "code": "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",
- "nonce": "0x0",
- "storage": {}
- },
- "0x57677bdc4f24d5c08ddce87e06670c26a00cac0b": {
- "balance": "0x0",
- "code": "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",
- "nonce": "0x1",
- "storage": {
- "0x1a89030203d60e0ad3b81bef15ce871dce0e07aae1860154d717eed1bcdf786": "0x18757dd9200006a277dc0019eaa432e30",
- "0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc": "0xb9f0bd0733c4aecd175186a09c0e160d28d12397",
- "0x36f93d1b992f5727acfd63b56bd8b6e1b802c83abc98ad9ea260c0c56ed63008": "0x2346d600006a277dc0019eaa432e30",
- "0x4e83eb67fb6976c1c8c8492885b74090afb5a9ef8837d5c63bdbbb849cdeb451": "0x81755400006a277dc0019eaa432e30",
- "0xa91154c2546f3abd80cd80f44e07b7e780e03f0a625896da84d11cf7227c7a7f": "0xdde7244da00006a277dc0019eaa432e30",
- "0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103": "0xa2b0067002df61df015c11b2cf0be4f34fc41cf8"
- }
- },
- "0xb9f0bd0733c4aecd175186a09c0e160d28d12397": {
- "balance": "0x0",
- "code": "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",
- "nonce": "0x1",
- "storage": {}
- },
- "0xd603f68957a482b41b5fd0489d00446a36dcbe1e": {
- "balance": "0xfeea3948195156e",
- "code": "0x",
- "nonce": "0x8237c4",
- "storage": {}
- }
- },
- "post": {
- "Rex5": [
- {
- "indexes": {
- "data": 0,
- "gas": 0,
- "value": 0
- },
- "hash": "0xf9684260d1dca8c06f299c57ab13efdc835c0970b29fc04e5b33b57d90ffad35",
- "logs": "0xc773337abbae20201effe79f9783f8f8ec164ab99e3cf2eda3d4015c88ae885d",
- "megaGasUsed": 600700,
- "megaStatus": "success"
- }
- ]
- },
- "transaction": {
- "type": 2,
- "data": [
- "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"
- ],
- "gasLimit": [
- "0x2625a0"
- ],
- "gasPrice": null,
- "nonce": "0x8237c4",
- "secretKey": "0x0000000000000000000000000000000000000000000000000000000000000000",
- "sender": "0xd603f68957a482b41b5fd0489d00446a36dcbe1e",
- "to": "0x57677bdc4f24d5c08ddce87e06670c26a00cac0b",
- "value": [
- "0x0"
- ],
- "maxFeePerGas": "0x124f80",
- "maxPriorityFeePerGas": "0x30d40",
- "initcodes": null,
- "accessLists": [
- []
- ],
- "authorizationList": null,
- "blobVersionedHashes": [],
- "maxFeePerBlobGas": null
- },
- "out": "0x",
- "megaEnv": {
- "bucketCapacities": [],
- "oracleStorage": []
- }
- }
-}
\ No newline at end of file
diff --git a/bench/replay/fixtures/log_heavy.json b/bench/replay/fixtures/log_heavy.json
deleted file mode 100644
index 28ab12c77..000000000
--- a/bench/replay/fixtures/log_heavy.json
+++ /dev/null
@@ -1,143 +0,0 @@
-{
- "replay_0x25db2df776d9192861893742b32bd5621a0a50ae911134dd862cad6fb11ebb76": {
- "_info": null,
- "env": {
- "currentChainID": "0x10e6",
- "currentCoinbase": "0x4200000000000000000000000000000000000011",
- "currentDifficulty": "0x0",
- "currentGasLimit": "0x2540be400",
- "currentNumber": "0x1155801",
- "currentTimestamp": "0x6a277dd4",
- "currentBaseFee": "0xf4240",
- "currentRandom": "0x257b1f30cba44be7941133b715be042b3e078c096663493d671e6606001cfe73",
- "currentExcessBlobGas": "0x0"
- },
- "pre": {
- "0x3416869d6f3de7d2ae20660d8041670592877c79": {
- "balance": "0x3b774e0cb8e2a43",
- "code": "0x",
- "nonce": "0x6c451b",
- "storage": {}
- },
- "0x4200000000000000000000000000000000000011": {
- "balance": "0x5147095e47043783",
- "code": "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",
- "nonce": "0x0",
- "storage": {}
- },
- "0x4200000000000000000000000000000000000019": {
- "balance": "0x30433220460642740",
- "code": "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",
- "nonce": "0x0",
- "storage": {}
- },
- "0x420000000000000000000000000000000000001a": {
- "balance": "0x38dfbb41ba696ac",
- "code": "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",
- "nonce": "0x0",
- "storage": {}
- },
- "0x420000000000000000000000000000000000001b": {
- "balance": "0x0",
- "code": "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",
- "nonce": "0x0",
- "storage": {}
- },
- "0x5e3ae52eba0f9740364bd5dd39738e1336086a8b": {
- "balance": "0x0",
- "code": "0x60806040526004361015610054575b34610050575f8073ffffffffffffffffffffffffffffffffffffffff680400000000000000005416368280378136915af43d5f803e1561004c573d5ff35b3d5ffd5b5f80fd5b5f3560e01c63661b33080361000e57346100505760607ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc3601126100505760043573ffffffffffffffffffffffffffffffffffffffff811681036100505760243573ffffffffffffffffffffffffffffffffffffffff81168103610050576044359173ffffffffffffffffffffffffffffffffffffffff831683036100505773ffffffffffffffffffffffffffffffffffffffff5f5416330361013457680400000000000000005568010000000000000000556802000000000000000055005b7f10c95c62000000000000000000000000000000000000000000000000000000005f5260045ffd",
- "nonce": "0x1",
- "storage": {
- "0x10000000000000014": "0x10a12120414fafddbb3fc7688494971a79cc65dca3ef82079e7",
- "0x40000000000000000": "0x7494c1319d44ac2e74964d02568a7ac32d921340",
- "0x40000000000000014": "0x140a000000040a1212070a4200000000000000000000000000000000000006",
- "0x5e00000001000000000000001e": "0x1ff2043ea60000000000000000000000000002cf0b88bca55f7b24c000",
- "0x3416869d6f3de7d2ae20660d8041670592877c79000040000000005e": "0x202",
- "0xf12fe484ab504276a454e750f54a9b7fbe5b06870000000000000028": "0x16000000000000a41000000000000186a00b0e03003200640000000400000001"
- }
- },
- "0x7494c1319d44ac2e74964d02568a7ac32d921340": {
- "balance": "0x0",
- "code": "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",
- "nonce": "0x1",
- "storage": {}
- },
- "0xf12fe484ab504276a454e750f54a9b7fbe5b0687": {
- "balance": "0x0",
- "code": "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",
- "nonce": "0x1",
- "storage": {
- "0x28": "0x3700000000000000000000000000000000000000090000003d",
- "0x32": "0x19000000000000000000000000000000000000001100000029",
- "0x100000032": "0x800000010095f20000000059b00000000000f424000000000005146a2",
- "0x200000001": "0xb0e030000000400000001",
- "0x700000032": "0x1e00000022095ef0000000059b00000000000f42400000000000513a22",
- "0x800000001": "0x1074f09648000000000000000000000000000000000000000000000000",
- "0x800000032": "0x1500000001096360000000005e000000008ff1f9c00000000000514402",
- "0xb00000001": "0x7a1205e3ae52eba0f9740364bd5dd39738e1336086a8b",
- "0xc00000032": "0x1900000024096480000000005e000000001200278000000000005125a2",
- "0x1000000032": "0x10000001d095f30000000059b00000000000f42400000000000514ac2",
- "0x1500000032": "0x2200000008095f10000000059b00000000000f42400000000000514262",
- "0x1600000028": "0x2e00000030095f90000000005e00000000908a9040000000000050ee02",
- "0x1900000032": "0xc096460000000005e000000004817816000000000005120a2",
- "0x1b00000028": "0x360000002e095e50000000059b00000000000f4240000000000050f362",
- "0x1e00000032": "0x2400000007095ee0000000059b00000000000f42400000000000081f01",
- "0x2200000032": "0x700000015095f00000000059b00000000000f42400000000000513e42",
- "0x2400000032": "0xc0000001e096440000000005e000000006c17d0600000000000512be2",
- "0x2e00000028": "0x1b00000016095e60000000059b00000000000f4240000000000050ef42",
- "0x3000000028": "0x1600000018095e70000000059b00000000000f4240000000000050eb22",
- "0x3500000028": "0x3700000039096410000000005e000000001207c8a00000000000511562",
- "0x3600000028": "0x390000001b095e40000000059b00000000000f4240000000000050f7a2",
- "0x3700000028": "0x35096450000000005e00000000481f22800000000000511aa2",
- "0x3900000028": "0x3500000036096330000000005e000000006c4597200000000000510b42"
- }
- }
- },
- "post": {
- "Rex5": [
- {
- "indexes": {
- "data": 0,
- "gas": 0,
- "value": 0
- },
- "hash": "0x9e34ed9cb72c8d145461686d3393a1d4eec33f06d0fb221f3802e2d3cbfdf857",
- "logs": "0x42335aab92f4801a8ca1d1617cb19f834135d437341ed5ed1f010cdb67c80285",
- "megaGasUsed": 456913,
- "megaStatus": "success"
- }
- ]
- },
- "transaction": {
- "type": 2,
- "data": [
- "0xd803a4cf000000000000000000000000000000000000000000000000000000000000005e0000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000000c00000000000000000010f12fe484ab504276a454e750f54a9b7fbe5b06870056000000000000000000000000481f22800000000000511b82000096450000003700000000000000000010f12fe484ab504276a454e750f54a9b7fbe5b068700560000000000000000000000001207c8a000000000005116e2000096410000003500000000000000000010f12fe484ab504276a454e750f54a9b7fbe5b068700560000000000000000000000006c3df6000000000000510fa2000096330000003900000000000000000010f12fe484ab504276a454e750f54a9b7fbe5b068700560000000000000000000000009082ef20000000000050f4a2000095f90000001600000000000000000010f12fe484ab504276a454e750f54a9b7fbe5b06870096000000000000000000000000481781600000000000512182000096460000001900000000000000000010f12fe484ab504276a454e750f54a9b7fbe5b068700960000000000000000000000008fea58a000000000005148620000963600000008"
- ],
- "gasLimit": [
- "0x28a640"
- ],
- "gasPrice": null,
- "nonce": "0x6c451b",
- "secretKey": "0x0000000000000000000000000000000000000000000000000000000000000000",
- "sender": "0x3416869d6f3de7d2ae20660d8041670592877c79",
- "to": "0x5e3ae52eba0f9740364bd5dd39738e1336086a8b",
- "value": [
- "0x0"
- ],
- "maxFeePerGas": "0x124f80",
- "maxPriorityFeePerGas": "0x0",
- "initcodes": null,
- "accessLists": [
- []
- ],
- "authorizationList": null,
- "blobVersionedHashes": [],
- "maxFeePerBlobGas": null
- },
- "out": "0x",
- "megaEnv": {
- "bucketCapacities": [],
- "oracleStorage": []
- }
- }
-}
\ No newline at end of file
diff --git a/bench/replay/fixtures/medium_call.json b/bench/replay/fixtures/medium_call.json
deleted file mode 100644
index 52171c0a6..000000000
--- a/bench/replay/fixtures/medium_call.json
+++ /dev/null
@@ -1,104 +0,0 @@
-{
- "replay_0x41d34e7e13dfe0f85da9d407e2b2c381955d8c7eed428b17dc82327b2616b000": {
- "_info": null,
- "env": {
- "currentChainID": "0x10e6",
- "currentCoinbase": "0x4200000000000000000000000000000000000011",
- "currentDifficulty": "0x0",
- "currentGasLimit": "0x2540be400",
- "currentNumber": "0x1154a2d",
- "currentTimestamp": "0x6a277000",
- "currentBaseFee": "0xf4240",
- "currentRandom": "0x5cd8791a477b467456670744425e11d5bd91fd54575d6d3bf80d761ab39d957f",
- "currentExcessBlobGas": "0x0"
- },
- "pre": {
- "0x14112799a39f2905b901067d3cd4a1f63c1cebda": {
- "balance": "0x2bb077a7d9ab1a",
- "code": "0x",
- "nonce": "0x195cb",
- "storage": {}
- },
- "0x4200000000000000000000000000000000000011": {
- "balance": "0x5125353fb2d2cd25",
- "code": "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",
- "nonce": "0x0",
- "storage": {}
- },
- "0x4200000000000000000000000000000000000019": {
- "balance": "0x303ca0651aedfa080",
- "code": "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",
- "nonce": "0x0",
- "storage": {}
- },
- "0x420000000000000000000000000000000000001a": {
- "balance": "0x38dd0ce3ffcb29e",
- "code": "0x60806040526004361061005e5760003560e01c80635c60da1b116100435780635c60da1b146100be5780638f283970146100f8578063f851a440146101185761006d565b80633659cfe6146100755780634f1ef286146100955761006d565b3661006d5761006b61012d565b005b61006b61012d565b34801561008157600080fd5b5061006b6100903660046106dd565b610224565b6100a86100a33660046106f8565b610296565b6040516100b5919061077b565b60405180910390f35b3480156100ca57600080fd5b506100d3610419565b60405173ffffffffffffffffffffffffffffffffffffffff90911681526020016100b5565b34801561010457600080fd5b5061006b6101133660046106dd565b6104b0565b34801561012457600080fd5b506100d3610517565b60006101577f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc5490565b905073ffffffffffffffffffffffffffffffffffffffff8116610201576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602560248201527f50726f78793a20696d706c656d656e746174696f6e206e6f7420696e6974696160448201527f6c697a656400000000000000000000000000000000000000000000000000000060648201526084015b60405180910390fd5b3660008037600080366000845af43d6000803e8061021e573d6000fd5b503d6000f35b7fb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d61035473ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff16148061027d575033155b1561028e5761028b816105a3565b50565b61028b61012d565b60606102c07fb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d61035490565b73ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff1614806102f7575033155b1561040a57610305846105a3565b6000808573ffffffffffffffffffffffffffffffffffffffff16858560405161032f9291906107ee565b600060405180830381855af49150503d806000811461036a576040519150601f19603f3d011682016040523d82523d6000602084013e61036f565b606091505b509150915081610401576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152603960248201527f50726f78793a2064656c656761746563616c6c20746f206e657720696d706c6560448201527f6d656e746174696f6e20636f6e7472616374206661696c65640000000000000060648201526084016101f8565b91506104129050565b61041261012d565b9392505050565b60006104437fb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d61035490565b73ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff16148061047a575033155b156104a557507f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc5490565b6104ad61012d565b90565b7fb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d61035473ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff161480610509575033155b1561028e5761028b8161060c565b60006105417fb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d61035490565b73ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff161480610578575033155b156104a557507fb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d61035490565b7f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc81815560405173ffffffffffffffffffffffffffffffffffffffff8316907fbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b90600090a25050565b60006106367fb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d61035490565b7fb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d61038381556040805173ffffffffffffffffffffffffffffffffffffffff80851682528616602082015292935090917f7e644d79422f17c01e4894b5f4f588d331ebfa28653d42ae832dc59e38c9798f910160405180910390a1505050565b803573ffffffffffffffffffffffffffffffffffffffff811681146106d857600080fd5b919050565b6000602082840312156106ef57600080fd5b610412826106b4565b60008060006040848603121561070d57600080fd5b610716846106b4565b9250602084013567ffffffffffffffff8082111561073357600080fd5b818601915086601f83011261074757600080fd5b81358181111561075657600080fd5b87602082850101111561076857600080fd5b6020830194508093505050509250925092565b600060208083528351808285015260005b818110156107a85785810183015185820160400152820161078c565b818111156107ba576000604083870101525b50601f017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe016929092016040019392505050565b818382376000910190815291905056fea164736f6c634300080f000a",
- "nonce": "0x0",
- "storage": {}
- },
- "0x420000000000000000000000000000000000001b": {
- "balance": "0x0",
- "code": "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",
- "nonce": "0x0",
- "storage": {}
- },
- "0x681e908b8ab57c49c74d770f369754ccc3e1ae09": {
- "balance": "0x0",
- "code": "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",
- "nonce": "0x1",
- "storage": {
- "0xd622e34f9f6e1c96032d45ead8ff60c54838d13000000000000000000000000": "0x5cdc2949000000000000000027bac86a060000000000000000019eaa0d787200",
- "0x95191f9da9b73a1282d7a8cae0d352b0b11bfadf2603d32929f695c1cdd9c42e": "0xd622e34f9f6e1c96032d45ead8ff60c54838d13",
- "0xb0296c0e3ea88b9cf74eaaf0baa46f18c015c86fd13c93e4236537bf71a16b1c": "0x300"
- }
- }
- },
- "post": {
- "Rex5": [
- {
- "indexes": {
- "data": 0,
- "gas": 0,
- "value": 0
- },
- "hash": "0x2231d71ba07daff0df2620ff18a3a91c23357f01b2552c30c03c9220db5f0abb",
- "logs": "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347",
- "megaGasUsed": 75514,
- "megaStatus": "success"
- }
- ]
- },
- "transaction": {
- "type": 2,
- "data": [
- "0x6a2770765cdc2b31000000000000000027ba5f49020000000000000000019eaa0d7bec00"
- ],
- "gasLimit": [
- "0x249f0"
- ],
- "gasPrice": null,
- "nonce": "0x195cb",
- "secretKey": "0x0000000000000000000000000000000000000000000000000000000000000000",
- "sender": "0x14112799a39f2905b901067d3cd4a1f63c1cebda",
- "to": "0x681e908b8ab57c49c74d770f369754ccc3e1ae09",
- "value": [
- "0x0"
- ],
- "maxFeePerGas": "0x200b20",
- "maxPriorityFeePerGas": "0x186a0",
- "initcodes": null,
- "accessLists": [
- []
- ],
- "authorizationList": null,
- "blobVersionedHashes": [],
- "maxFeePerBlobGas": null
- },
- "out": "0x",
- "megaEnv": {
- "bucketCapacities": [],
- "oracleStorage": []
- }
- }
-}
\ No newline at end of file
diff --git a/bench/replay/fixtures/system_call.json b/bench/replay/fixtures/system_call.json
deleted file mode 100644
index b08d0d07b..000000000
--- a/bench/replay/fixtures/system_call.json
+++ /dev/null
@@ -1,86 +0,0 @@
-{
- "replay_0x722a6878f48952f3906045547c18270a060e8415be534046719002fa096d9299": {
- "_info": null,
- "env": {
- "currentChainID": "0x10e6",
- "currentCoinbase": "0x4200000000000000000000000000000000000011",
- "currentDifficulty": "0x0",
- "currentGasLimit": "0x2540be400",
- "currentNumber": "0x1155808",
- "currentTimestamp": "0x6a277ddb",
- "currentBaseFee": "0xf4240",
- "currentRandom": "0x257b1f30cba44be7941133b715be042b3e078c096663493d671e6606001cfe73",
- "currentExcessBlobGas": "0x0"
- },
- "pre": {
- "0x6342000000000000000000000000000000000001": {
- "balance": "0x0",
- "code": "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",
- "nonce": "0x0",
- "storage": {
- "0x0": "0x653c91816c1bd"
- }
- },
- "0x6342000000000000000000000000000000000006": {
- "balance": "0x0",
- "code": "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",
- "nonce": "0x0",
- "storage": {
- "0x0": "0xa887dcb9d5f39ef79272801d05abdf707cfbbd1d"
- }
- },
- "0xa887dcb9d5f39ef79272801d05abdf707cfbbd1d": {
- "balance": "0x0",
- "code": "0x",
- "nonce": "0x98191c7",
- "storage": {}
- }
- },
- "post": {
- "Rex5": [
- {
- "indexes": {
- "data": 0,
- "gas": 0,
- "value": 0
- },
- "hash": "0x05fb521b8bd2559574f433c2871a5d27d50dcb32fef0028b94645a048c847c99",
- "logs": "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347",
- "megaGasUsed": 81740,
- "megaStatus": "success"
- }
- ]
- },
- "transaction": {
- "type": 0,
- "data": [
- "0x01caec1300000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000653c91818250f"
- ],
- "gasLimit": [
- "0x253e8c4e4"
- ],
- "gasPrice": "0x0",
- "nonce": "0x98191c7",
- "secretKey": "0x0000000000000000000000000000000000000000000000000000000000000000",
- "sender": "0xa887dcb9d5f39ef79272801d05abdf707cfbbd1d",
- "to": "0x6342000000000000000000000000000000000001",
- "value": [
- "0x0"
- ],
- "maxFeePerGas": null,
- "maxPriorityFeePerGas": null,
- "initcodes": null,
- "accessLists": [
- null
- ],
- "authorizationList": null,
- "blobVersionedHashes": [],
- "maxFeePerBlobGas": null
- },
- "out": "0x",
- "megaEnv": {
- "bucketCapacities": [],
- "oracleStorage": []
- }
- }
-}
\ No newline at end of file
diff --git a/bench/replay/manifest.json b/bench/replay/manifest.json
deleted file mode 100644
index 68699eaa2..000000000
--- a/bench/replay/manifest.json
+++ /dev/null
@@ -1,47 +0,0 @@
-{
- "description": "Characteristic MegaETH workloads for the replay-throughput benchmark. Each case is a self-contained state-test fixture (pre-state + tx + env + megaEnv), replayed offline in isolation — no RPC, no archive node. Most are real mainnet transactions dumped via `mega-evme replay --dump-fixture`; non-on-chain cases (e.g. attack snapshots) use the same format. See run.py and README.md.",
- "default_runs": 50,
- "default_warmup": 5,
- "cases": [
- {
- "name": "system_call",
- "category": "system-contract",
- "type": "fixture",
- "fixture": "fixtures/system_call.json",
- "expected_gas": 81740,
- "note": "Call into a 0x6342… system contract — exercises interceptor dispatch and volatile-data/oracle paths."
- },
- {
- "name": "medium_call",
- "category": "plain-call",
- "type": "fixture",
- "fixture": "fixtures/medium_call.json",
- "expected_gas": 75514,
- "note": "Medium contract call with no logs — baseline compute + a few SLOAD/SSTORE."
- },
- {
- "name": "log_heavy",
- "category": "logs",
- "type": "fixture",
- "fixture": "fixtures/log_heavy.json",
- "expected_gas": 456913,
- "note": "12 logs — exercises LOG opcodes and the dual (compute + storage) gas metering on topics/data."
- },
- {
- "name": "large_defi",
- "category": "heavy",
- "type": "fixture",
- "fixture": "fixtures/large_defi.json",
- "expected_gas": 600700,
- "note": "Large multi-call DeFi transaction — deep call stack, many storage writes."
- },
- {
- "name": "attack_deploy",
- "category": "attack/limit-stress",
- "type": "fixture",
- "fixture": "fixtures/attack_deploy.json",
- "expected_gas": 141927106,
- "note": "Mainnet attack contract deployment captured as a self-contained prestate fixture (not a mined tx; converted from crates/mega-evm/benches/fixtures/known_attack_deploy.json, #299). 142M gas of CREATE — the heaviest stress on the multi-dimensional AdditionalLimit accounting. Its post was filled offline (`state-test --fill --bench-spec Rex5`), so it is validated and benched like the others."
- }
- ]
-}
diff --git a/bench/replay/run.py b/bench/replay/run.py
deleted file mode 100644
index aff5e823a..000000000
--- a/bench/replay/run.py
+++ /dev/null
@@ -1,304 +0,0 @@
-#!/usr/bin/env python3
-"""Replay-throughput benchmark driver for mega-evm.
-
-Runs a corpus of characteristic MegaETH workloads through ``state-test --bench``
-fully offline — each case is a self-contained state-test fixture (pre-state +
-tx + env), so the benchmark is deterministic and needs no network — and reports
-per-case EVM throughput.
-
-With a single ``--bin`` it just measures (useful for a baseline or a quick local
-check). With two ``--bin`` entries it does an **ABBA-interleaved** base-vs-PR
-comparison: for each case the two binaries are run in alternating order across
-several rounds so that slow monotonic drift on the CI machine cancels out, then
-the median of each binary's samples is compared. A case whose PR median is more
-than ``--threshold-pct`` slower than base is flagged as a regression (and, with
-``--fail-on-regression``, fails the run).
-
-The driver shells out to ``state-test`` and parses the single-document JSON it
-prints; it has no third-party dependencies. ``--bin`` is a build directory (or
-the path to a binary in one); the ``state-test`` binary is resolved from it.
-
-Manifest format (JSON)::
-
- {
- "default_runs": 50,
- "default_warmup": 5,
- "cases": [
- {
- "name": "erc20_transfer",
- "category": "storage+log",
- "fixture": "fixtures/erc20_transfer.json",
- "expected_gas": 51234,
- "spec": "Rex5",
- "note": "USDC transfer: 1 log, 2 SSTORE"
- }
- ]
- }
-
-``spec`` is optional (defaults to the fixture's single ``post`` spec). ``fixture``
-paths are resolved relative to the manifest file.
-"""
-
-from __future__ import annotations
-
-import argparse
-import json
-import statistics
-import subprocess
-import sys
-from dataclasses import dataclass
-from pathlib import Path
-
-
-@dataclass
-class Measurement:
- """One binary's measured throughput for one transaction."""
-
- median_ns: float
- mgas_per_sec: float
- gas_used: int
-
-
-def resolve_state_test(path: str) -> str:
- """Resolve the ``state-test`` binary from one ``--bin`` value.
-
- ``path`` may be a build directory containing the binary, or the path to a
- binary in one (``state-test`` is then taken as a sibling) — so both
- ``--bin target/release`` and ``--bin target/release/mega-evme`` work.
- """
- p = Path(path)
- return str(p / "state-test") if p.is_dir() else str(p.parent / "state-test")
-
-
-def run_case(state_test: str, case: dict, manifest_dir: Path, runs: int, warmup: int) -> Measurement:
- """Benchmark one self-contained fixture case via ``state-test --bench``."""
- fixture = (manifest_dir / case["fixture"]).resolve()
- cmd = [state_test, "--bench", "--bench-runs", str(runs), "--bench-warmup", str(warmup)]
- if case.get("spec"):
- cmd += ["--bench-spec", case["spec"]]
- cmd.append(str(fixture))
-
- proc = subprocess.run(cmd, capture_output=True, text=True, timeout=600)
- if proc.returncode != 0:
- raise RuntimeError(
- f"{case['name']} failed (exit {proc.returncode}):\n{proc.stderr.strip()}"
- )
- try:
- out = json.loads(proc.stdout.strip())
- except json.JSONDecodeError as exc:
- raise RuntimeError(f"could not parse bench JSON for {case['name']}: {exc}") from exc
- bench = out.get("bench")
- if bench is None:
- raise RuntimeError(f"no `bench` field in output for {case['name']}")
- return Measurement(
- median_ns=float(bench["medianNs"]),
- mgas_per_sec=float(bench["mgasPerSec"]),
- gas_used=int(out["gas_used"]),
- )
-
-
-def measure_abba(
- binaries: list[tuple[str, str]],
- case: dict,
- manifest_dir: Path,
- runs: int,
- warmup: int,
- rounds: int,
-) -> dict[str, Measurement]:
- """Collect `rounds` samples per binary, interleaving order each round.
-
- Round r runs the binaries in normal order when r is even and reversed when r
- is odd (A B / B A / A B ...), so a machine that slowly speeds up or slows
- down over the run does not systematically favor either binary. The reported
- measurement per binary is the median of its per-round samples.
- """
- samples: dict[str, list[Measurement]] = {label: [] for label, _ in binaries}
- for r in range(rounds):
- order = binaries if r % 2 == 0 else list(reversed(binaries))
- for label, state_test in order:
- samples[label].append(run_case(state_test, case, manifest_dir, runs, warmup))
- result: dict[str, Measurement] = {}
- for label, _ in binaries:
- ss = samples[label]
- result[label] = Measurement(
- median_ns=statistics.median(s.median_ns for s in ss),
- mgas_per_sec=statistics.median(s.mgas_per_sec for s in ss),
- gas_used=ss[0].gas_used,
- )
- return result
-
-
-def fmt_ns(ns: float) -> str:
- if ns >= 1_000_000:
- return f"{ns / 1_000_000:.3f} ms"
- if ns >= 1_000:
- return f"{ns / 1_000:.2f} µs"
- return f"{ns:.0f} ns"
-
-
-def classify(delta_pct: float, threshold: float) -> str:
- """Marker for a median-time delta (positive = slower = regression)."""
- if delta_pct > threshold:
- return "🔴 regression"
- if delta_pct < -threshold:
- return "🟢 improvement"
- return "⚪ noise"
-
-
-def build_report(
- cases: list[dict],
- results: list[dict[str, Measurement]],
- labels: list[str],
- threshold: float,
-) -> tuple[str, dict, int]:
- """Render a markdown table and a machine-readable summary.
-
- Returns (markdown, json_summary, regression_count). Comparison columns are
- only emitted when exactly two binaries were measured (labels[0] = base,
- labels[1] = pr).
- """
- compare = len(labels) == 2
- lines: list[str] = []
- if compare:
- base, pr = labels
- lines.append(f"| transaction | category | gas | `{base}` median | `{pr}` median | Δ time | `{base}` Mgas/s | `{pr}` Mgas/s | verdict |")
- lines.append("|---|---|--:|--:|--:|--:|--:|--:|---|")
- else:
- only = labels[0]
- lines.append(f"| transaction | category | gas | `{only}` median | `{only}` Mgas/s |")
- lines.append("|---|---|--:|--:|--:|")
-
- regressions = 0
- improvements = 0
- json_cases = []
- for case, res in zip(cases, results):
- name, cat, gas = case["name"], case.get("category", ""), case["expected_gas"]
- if compare:
- base, pr = labels
- b, p = res[base], res[pr]
- if b.median_ns <= 0:
- sys.exit(f"case {name}: baseline median is zero; cannot compute a delta")
- delta = (p.median_ns - b.median_ns) / b.median_ns * 100.0
- verdict = classify(delta, threshold)
- regressions += verdict.startswith("🔴")
- improvements += verdict.startswith("🟢")
- lines.append(
- f"| {name} | {cat} | {gas:,} | {fmt_ns(b.median_ns)} | {fmt_ns(p.median_ns)} | "
- f"{delta:+.1f}% | {b.mgas_per_sec:,.0f} | {p.mgas_per_sec:,.0f} | {verdict} |"
- )
- json_cases.append(
- {
- "name": name,
- "category": cat,
- "gas": gas,
- "base_median_ns": b.median_ns,
- "pr_median_ns": p.median_ns,
- "delta_pct": delta,
- "base_mgas_per_sec": b.mgas_per_sec,
- "pr_mgas_per_sec": p.mgas_per_sec,
- "verdict": verdict,
- }
- )
- else:
- only = labels[0]
- m = res[only]
- lines.append(
- f"| {name} | {cat} | {gas:,} | {fmt_ns(m.median_ns)} | {m.mgas_per_sec:,.0f} |"
- )
- json_cases.append(
- {
- "name": name,
- "category": cat,
- "gas": gas,
- "median_ns": m.median_ns,
- "mgas_per_sec": m.mgas_per_sec,
- }
- )
-
- md = "\n".join(lines)
- if compare:
- summary = (
- f"\n\n**{len(cases)} transactions — "
- f"{regressions} regression(s), {improvements} improvement(s)** "
- f"(threshold ±{threshold:.1f}% on median time; ABBA-interleaved)."
- )
- md += summary
- json_summary = {
- "threshold_pct": threshold,
- "labels": labels,
- "regressions": regressions,
- "improvements": improvements,
- "cases": json_cases,
- }
- return md, json_summary, regressions
-
-
-def parse_bin(spec: str) -> tuple[str, str]:
- if "=" not in spec:
- raise argparse.ArgumentTypeError(f"--bin must be LABEL=PATH, got {spec!r}")
- label, path = spec.split("=", 1)
- return label, path
-
-
-def main() -> int:
- here = Path(__file__).resolve().parent
- ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
- ap.add_argument("--manifest", type=Path, default=here / "manifest.json")
- ap.add_argument(
- "--bin",
- type=parse_bin,
- action="append",
- required=True,
- metavar="LABEL=PATH",
- help="binary to measure; pass twice (base then pr) to compare",
- )
- ap.add_argument("--runs", type=int, default=None, help="timed iterations per invocation")
- ap.add_argument("--warmup", type=int, default=None, help="discarded warmup iterations")
- ap.add_argument("--rounds", type=int, default=5, help="ABBA rounds per transaction")
- ap.add_argument("--threshold-pct", type=float, default=5.0)
- ap.add_argument("--json-out", type=Path, default=None)
- ap.add_argument("--markdown-out", type=Path, default=None)
- ap.add_argument("--fail-on-regression", action="store_true")
- args = ap.parse_args()
-
- if len(args.bin) > 2:
- ap.error("at most two --bin entries (base and pr) are supported")
-
- manifest = json.loads(args.manifest.read_text())
- runs = args.runs or manifest.get("default_runs", 50)
- warmup = args.warmup if args.warmup is not None else manifest.get("default_warmup", 5)
- cases = manifest["cases"]
- labels = [label for label, _ in args.bin]
- binaries = [(label, resolve_state_test(path)) for label, path in args.bin]
- manifest_dir = args.manifest.resolve().parent
-
- results: list[dict[str, Measurement]] = []
- for case in cases:
- res = measure_abba(binaries, case, manifest_dir, runs, warmup, args.rounds)
- # Sanity: every binary must reproduce the recorded on-chain gas, or the
- # comparison is meaningless (different work being timed).
- for label, m in res.items():
- if m.gas_used != case["expected_gas"]:
- raise SystemExit(
- f"{label} replayed {case['name']} with gas {m.gas_used} != "
- f"expected {case['expected_gas']} — corpus/binary mismatch"
- )
- results.append(res)
- print(f" measured {case['name']} ({len(labels)} bin × {args.rounds} rounds)", file=sys.stderr)
-
- md, summary, regressions = build_report(cases, results, labels, args.threshold_pct)
- title = "## Replay throughput benchmark\n\n"
- print(title + md)
- if args.markdown_out:
- args.markdown_out.write_text(title + md + "\n")
- if args.json_out:
- args.json_out.write_text(json.dumps(summary, indent=2))
-
- if args.fail_on_regression and regressions:
- print(f"\n::error::{regressions} transaction(s) regressed beyond {args.threshold_pct:.1f}%", file=sys.stderr)
- return 1
- return 0
-
-
-if __name__ == "__main__":
- raise SystemExit(main())
diff --git a/bin/mega-evme/AGENTS.md b/bin/mega-evme/AGENTS.md
index 7dc0e9460..96d1408c1 100644
--- a/bin/mega-evme/AGENTS.md
+++ b/bin/mega-evme/AGENTS.md
@@ -2,23 +2,36 @@
## OVERVIEW
CLI toolbox for direct MegaEVM execution (`run`, `tx`, `replay`) with optional forking, tracing, and state dump workflows.
+Two engines: the in-tree sources run Satin; a spec from `Equivalence` to `Rex6` runs on the released `mega-evme` 1.7.1 and `mega-evm` 1.7.1, linked as `mega-evme-legacy` / `mega-evm-legacy` (feature `legacy`, on by default).
## STRUCTURE
-- `src/main.rs`: CLI bootstrap and panic hook.
-- `src/cmd.rs`: top-level command dispatch and error surface.
-- `src/common/`: shared CLI args, state loading, tracing, tx parsing, output printers.
+- `src/main.rs`: the binary: installs the panic hook and hands the arguments to `cmd::run_cli`.
+- `src/lib.rs`: the library every command lives in: the module declarations and the panic hook (`set_thread_panic_hook`).
+- `src/cmd.rs`: argument parsing, engine selection, and dispatch; `--genesis` is applied here (a `run` or `tx` that left `--spec` out runs Satin under it), and the chain is checked against the file before the engine is picked.
+- `src/engine.rs`: which engine a spec or a block runs on; the hand-off to the legacy CLI, which gets a legacy spec's arguments unchanged but for `--spec Rex6` added, before any `--`, to a `run` or `tx` that left `--spec` out (the 1.7.1 default is `Rex7`).
+- `src/common/`: shared CLI args, state loading, tracing, tx parsing, output printers; `schedule.rs` is the one place a Satin run's hardfork schedule, and so its protocol limits, is chosen, `--override.limits` included.
- `src/run/`: bytecode execution command.
- `src/tx/`: full transaction execution command with raw-tx override support.
-- `src/replay/`: RPC-backed historical transaction replay through block executor.
+- `src/replay/`: RPC-backed historical transaction replay through block executor (Satin; a legacy spec is the 1.7.1 CLI's).
+- `src/block/`: `replay --block`, whole blocks on either engine compared with the chain: inputs and the block cache (`inputs.rs`), the parent state in plain data (`state.rs`), one executor per engine exchanging only plain data (`satin.rs`, `legacy.rs`), the plain data both hand back (`exec.rs`), records and the comparison (`record.rs`), the driver (`cmd.rs`).
+- `tests/fixtures/blocks.tar.xz`: the three recorded Rex6 blocks and their code store in the block cache layout, one deterministic archive extracted once per test binary (`tests/common/mod.rs`); `scripts/pack_blocks_fixture.py ` repacks it, `--check` requires a repack of the committed archive to be byte-identical.
+- `tests/satin-differences.md`: the pinned differences between the engines, rendered by `tests/differences.rs` (`UPDATE_EVME_DIFFERENCES=1` rewrites it).
## KEY PATTERNS
-- Shared argument groups are flattened from `run` argument structs into sibling commands.
+- Shared argument groups are defined in `src/common/` and flattened into each command; `run` re-exports them, and `tx` names them through it (`crate::run::TxArgs`).
- Command handlers follow staged flow: parse inputs → build state/env → execute → print summary/receipt/trace.
- Replay uses block executor flow, including pre-execution system calls and preceding transactions.
- Logging is structured via tracing macros, with explicit progress milestones.
- Output paths keep both human-readable summaries and optional machine artifacts (trace/state dump).
+- The engine is decided where a command needs it (`cmd.rs` for `run`/`tx`, `replay::Cmd::engine` for a transaction replay, `block/cmd.rs` per block), always through `Engine` (`of_spec`, `of_block`, `of_chain`), and a Satin run's schedule through `common::satin_schedule`; both read the chain's activation table, so they agree. A transaction replay's engine is decided at the timestamp of the block the replay runs it in (its own, or the latest for a pending one), the one whose schedule it runs under: keep a new site to the same pair.
+- Output on Satin is additive to the legacy output: every legacy field keeps its name and meaning, and what only Satin counts goes in the `satin` object (`tests/integration.rs` checks it on every fixture pair).
+
## ANTI-PATTERNS
+- Do not edit or re-implement the legacy leg: it is the released 1.7.1 code, pinned with its dependency versions (`tests/legacy_line.rs`).
+- Do not move a package `tests/legacy_line.rs` pins without deciding it there. The leg shares most of its dependencies with the Satin engine and the tool, one copy per compatibility line: the precompiles' backends (`secp256k1`, `k256`, `sha2`, `ripemd`, `aurora-engine-modexp`, arkworks, `blst`, `c-kzg`, `p256`), hashing and word arithmetic (`alloy-primitives`, `ruint`, `sha3`) and the encodings. Each is pinned at the release's version; `alloy-rlp`, `alloy-trie` and the `alloy-sol-types` family, which the Satin engine's alloy 2 line holds above it, are pinned at the version the workspace holds (`AHEAD_OF_THE_RELEASE`). Transport, JSON and derive crates float.
+- Do not use `cargo ... -p mega-evme`: the name also matches the linked 1.7.1 package. Use `--manifest-path bin/mega-evme/Cargo.toml`.
+- Build no Satin hardfork schedule in the CLI but the counterfactual's (`common::schedule::counterfactual`): the chain's own schedule with Satin from genesis, or the engine's base forks with Satin from genesis for a chain the table does not know. A chain's own Satin schedule — the engine's table's (`mega_evm::hardfork_schedule`, which knows mainnet and testnet and no other chain), or the one `mega_evm::SatinChainConfig::hardforks` builds from the chain's genesis file (`--genesis`) — is used as it is or refused. A replay of a chain neither names is refused unless `--override.spec` names the engine (`engine::unknown_chain`). Under `--genesis` no Satin run is a counterfactual: one the file does not run on Satin is refused (`satin_schedule`), and the file's chain is checked before a command's engine is picked (`check_genesis_chain`). Do not parse a genesis file's Satin keys here either: `SatinChainConfig::from_genesis_config` is the one parser every reader shares.
- Do not duplicate chain/spec parsing logic across commands.
- Add shared parsing in `src/common/` and reuse.
- Do not print partial execution output before final outcome object assembly.
@@ -26,8 +39,8 @@ CLI toolbox for direct MegaEVM execution (`run`, `tx`, `replay`) with optional f
- Do not mutate command-level defaults in one subcommand without mirroring related aliases/help text.
## WHERE TO LOOK
-- Add a new top-level command: `src/cmd.rs` enum + module wiring in `src/main.rs`.
+- Add a new top-level command: `src/cmd.rs` enum + module wiring in `src/lib.rs`.
- Add a new shared CLI option family: `src/common/*` and flatten into command structs.
- Change state-forking or prestate merge semantics: `src/common/state.rs`.
-- Change replay hardfork/spec selection: `src/replay/{cmd.rs,hardforks.rs}`.
+- Change which engine a spec or block runs on: `src/engine.rs`; which Satin schedule and limits it runs under: `src/common/schedule.rs`, which also holds the genesis file a run was given (`--genesis`) and the activation table `src/engine.rs` reads through it.
- Change receipt/summary formatting: `src/common/outcome.rs` and printer helpers.
diff --git a/bin/mega-evme/Cargo.toml b/bin/mega-evme/Cargo.toml
index ea3a8a712..13ec51fe6 100644
--- a/bin/mega-evme/Cargo.toml
+++ b/bin/mega-evme/Cargo.toml
@@ -9,6 +9,8 @@ repository.workspace = true
description = "MegaETH executable EVM"
readme = "README.md"
default-run = "mega-evme"
+# Test data and the scripts that pack it stay out of the published crate.
+exclude = ["scripts/", "tests/fixtures/"]
[lints]
workspace = true
@@ -20,9 +22,11 @@ path = "src/main.rs"
[dependencies]
# megaeth
mega-evm = { workspace = true, features = ["default", "test-utils"] }
-mega-state-test.workspace = true
+mega-evm-legacy = { workspace = true, optional = true, features = ["std", "test-utils"] }
+mega-evme-legacy = { workspace = true, optional = true }
# revm
+revm = { workspace = true, features = ["alloydb"] }
revm-inspectors = { workspace = true, features = ["std"] }
# alloy
@@ -39,6 +43,7 @@ alloy-serde = { workspace = true, features = ["default"] }
alloy-sol-types.workspace = true
alloy-transport.workspace = true
alloy-transport-http = { workspace = true, features = ["reqwest"] }
+alloy-trie = { workspace = true, features = ["std", "ethereum"] }
# op
op-alloy-consensus.workspace = true
@@ -48,22 +53,27 @@ op-alloy-rpc-types.workspace = true
# misc
clap = { workspace = true, features = ["default", "env"] }
dirs.workspace = true
-reqwest = "0.12"
serde.workspace = true
serde_json.workspace = true
tempfile.workspace = true
thiserror.workspace = true
-tokio = { workspace = true, features = ["rt", "macros"] }
-tower = { version = "0.5", default-features = false }
+tokio = { workspace = true, features = ["rt", "rt-multi-thread", "macros"] }
+tower.workspace = true
tracing.workspace = true
tracing-subscriber = { workspace = true, features = ["fmt", "env-filter", "std", "ansi"] }
+zstd.workspace = true
[dev-dependencies]
mega-evme = { path = ".", features = ["test-utils"] }
+mega-state-test-legacy.workspace = true
rstest.workspace = true
wiremock.workspace = true
[features]
+default = ["legacy"]
+# The legacy leg: specs `Equivalence` through `Rex6` run on the released 1.7.1 CLI and engine,
+# linked beside the Satin engine. Without it the binary runs Satin only.
+legacy = ["dep:mega-evm-legacy", "dep:mega-evme-legacy"]
test-utils = []
[lib]
diff --git a/bin/mega-evme/README.md b/bin/mega-evme/README.md
index 63ef5a55d..a8510ddf7 100644
--- a/bin/mega-evme/README.md
+++ b/bin/mega-evme/README.md
@@ -17,11 +17,28 @@ A command-line tool for executing and debugging EVM bytecode, similar to go-ethe
`mega-evme` provides three main commands for EVM execution:
-| Command | Description |
-| -------- | ----------------------------------------------- |
-| `run` | Execute arbitrary EVM bytecode directly |
-| `tx` | Run a transaction with full transaction context |
-| `replay` | Replay an existing transaction from RPC |
+| Command | Description |
+| -------- | ------------------------------------------------------------------------ |
+| `run` | Execute arbitrary EVM bytecode directly |
+| `tx` | Run a transaction with full transaction context |
+| `replay` | Replay an existing transaction, or whole blocks compared with the chain |
+
+### Two engines
+
+Every command runs on the engine its spec names.
+`Satin` runs on the Satin engine, this repository's `mega-evm`.
+`Equivalence` through `Rex6` run on the legacy engine: the released `mega-evme` and `mega-evm` 1.7.1, linked in as `mega-evme-legacy` and `mega-evm-legacy`, which receive the command's arguments unchanged, so a legacy spec prints exactly what the 1.7.1 tool printed.
+`Rex7` is refused: it never activated on a chain, and Satin supersedes it.
+
+On Satin every output field keeps its legacy name and meaning, and a `satin` object is added with the gas by ledger (`regular_gas`, `state_gas`, `history_gas`, `history_bytes`, `reservoir_remaining`, `floor_gas`) and the limits' counts (`data_size`, `write_records`, `limit_exceeded`, and under `--override.limits` the limits the run was held to, `limits_override`).
+`tests/integration.rs` checks that on every fixture pair, and `tests/satin-differences.md` pins what the two engines produce on the same inputs.
+
+A Satin run is held to Satin's protocol limits, which the spec fixes for every chain.
+`--override.limits ` on `run`, `tx` and `replay` replaces the fields it names of those limits, a counterfactual; it is refused on a legacy spec.
+`--genesis ` gives a chain the tool does not know, a devnet for one, its own Satin configuration: its genesis file's `satinTime` replaces the tool's table for that chain, read with the parser a node reads it with.
+Under it `run` and `tx` default to `--spec Satin`, and a run the file cannot configure — on another chain, on a legacy spec, before the file's `satinTime`, or on a file without Satin keys — is refused rather than run on the tool's table.
+
+The legacy leg is the default feature `legacy`; `--no-default-features` builds a Satin-only binary.
## Installation
@@ -34,10 +51,13 @@ cargo install mega-evme --locked
Or build from source:
```bash
-cargo build --release -p mega-evme
+cargo build --release --manifest-path bin/mega-evme/Cargo.toml
# The binary will be at target/release/mega-evme
```
+Select the tool by manifest path, not with `-p mega-evme`: it links the released `mega-evme` 1.7.1, a package of the same name, so `-p mega-evme` names two packages.
+The same holds for its tests: `cargo test --manifest-path bin/mega-evme/Cargo.toml`.
+
The `--locked` flag ensures the exact tested dependency versions are used.
### Prebuilt binary
@@ -100,7 +120,7 @@ mega-evme run --create 0x6080604052...
| `--input ` | Input data as hex string |
| `--inputfile ` | Path to file containing input data |
-For detailed documentation, see [run/README.md](src/run/README.md).
+For detailed documentation, see [the `run` command's page](../../docs/mega-evme/commands/run.md).
---
@@ -113,10 +133,10 @@ Run a transaction with full transaction context. Similar to `run`, but with addi
mega-evme tx --input 0x1234 --receiver 0x1234...
# Fork state from remote RPC
-mega-evme tx --fork --fork.rpc https://rpc.example.com --receiver 0x1234...
+mega-evme tx --fork --rpc https://rpc.example.com --receiver 0x1234...
# Fork from specific block
-mega-evme tx --fork --fork.block 12345678 --receiver 0x1234...
+mega-evme tx --fork --rpc https://rpc.example.com --fork.block 12345678 --receiver 0x1234...
```
#### Transaction Options
@@ -189,27 +209,25 @@ mega-evme tx --tx-type 4 \
#### Fork Options
-| Option | Default | Description |
-| ----------------------- | --------------------- | ------------------------------------ |
-| `--fork` | false | Enable state forking from RPC |
-| `--fork.rpc ` | http://localhost:8545 | RPC URL for forking (env: `RPC_URL`) |
-| `--fork.block ` | latest | Block number to fork from |
+| Option | Default | Description |
+| ----------------------- | --------------- | -------------------------------------------------------------------------------------------- |
+| `--fork` | false | Enable state forking from RPC |
+| `--rpc ` | none — required | RPC URL for forking (alias `--rpc-url`; `--fork.rpc` is accepted); `RPC_URL` is not read |
+| `--fork.block ` | latest | Block number to fork from |
---
### replay Command
Replay an existing transaction from RPC. Fetches the transaction and its execution context from a remote node and re-executes it locally.
+The spec, and so the engine, comes from the chain's schedule at the block's timestamp; `--override.spec Satin` replays the transaction as it would run on Satin.
```bash
# Replay a transaction
-mega-evme replay 0x1234...txhash...5678
-
-# Replay with custom RPC
-mega-evme replay 0x1234...txhash --rpc https://rpc.example.com
+mega-evme replay 0x1234...txhash...5678 --rpc https://rpc.example.com
# Replay with execution trace
-mega-evme replay 0x1234...txhash --trace
+mega-evme replay 0x1234...txhash --rpc https://rpc.example.com --trace
```
#### Arguments
@@ -220,9 +238,9 @@ mega-evme replay 0x1234...txhash --trace
#### Options
-| Option | Default | Description |
-| ------------- | --------------------- | --------------------------------- |
-| `--rpc ` | http://localhost:8545 | RPC URL to fetch transaction from |
+| Option | Default | Description |
+| ------------- | --------------- | ----------------------------------------------------------------------------------------------------------- |
+| `--rpc ` | none — required | RPC URL to fetch the transaction from (alias `--rpc-url`; `--fork.rpc` is accepted); `RPC_URL` is not read |
#### Transaction Override Options
@@ -246,6 +264,28 @@ mega-evme replay 0x1234...txhash --override.input 0xabcdef
mega-evme replay 0x1234...txhash --override.input-file calldata.hex
```
+#### Whole Blocks
+
+`--block N[..M]` replays whole blocks, each on the engine its spec names, and compares every receipt (status, gas used, cumulative gas used, logs) and the receipts root with the chain's; the state the block leaves is not compared with the header's state root.
+
+| Option | Description |
+| --------------------- | ------------------------------------------------------------------------------------------------------- |
+| `--block ` | Replay block N, or blocks N through M |
+| `--block-cache ` | Read blocks from DIR; write blocks fetched over `--rpc` to it, with what their replay read beyond the trace |
+| `--verify` | Exit with code 2 when a block differs from the chain |
+| `--json` | One JSON record per transaction and per block |
+
+```bash
+# Check 200 blocks against the chain and record them
+mega-evme replay --block 26400000..26400199 --rpc https://mainnet.megaeth.com/rpc --block-cache ./blocks --verify
+
+# The same blocks on Satin, as NDJSON (the first Satin run reads the L1 fee overhead slot over RPC;
+# later runs of the same blocks can drop --rpc)
+mega-evme replay --block 26400000..26400199 --rpc https://mainnet.megaeth.com/rpc --block-cache ./blocks --override.spec Satin --json > satin.ndjson
+```
+
+Fetching a block needs an archive endpoint with the `debug` namespace (`debug_traceBlockByNumber` with `prestateTracer`); a cached block replays offline.
+
---
## Common Options
@@ -265,7 +305,7 @@ These options are available across all commands.
| Option | Default | Description |
| ---------------------- | ------- | ----------------------------------------- |
-| `--spec ` | Rex7 | Spec: `Equivalence`, `MiniRex`, `MiniRex1`, `MiniRex2`, `Rex`, `Rex1`, `Rex2`, `Rex3`, `Rex4`, `Rex5`, `Rex6`, `Rex7` (`MiniRex1`/`MiniRex2` are aliases executing `Equivalence`/`MiniRex` behavior) |
+| `--spec ` | Rex6 | Spec: `Satin` (the Satin engine), or `Equivalence`, `MiniRex`, `MiniRex1`, `MiniRex2`, `Rex`, `Rex1`, `Rex2`, `Rex3`, `Rex4`, `Rex5`, `Rex6` (the legacy engine; `MiniRex1`/`MiniRex2` are aliases executing `Equivalence`/`MiniRex` behavior); `Satin` by default under `--genesis` |
| `--chain-id ` | 6342 | Chain ID |
### Block Environment
@@ -350,7 +390,7 @@ mega-evme run --create 0x6080604052... --dump
# Fork mainnet state and execute against a contract
mega-evme tx \
--fork \
- --fork.rpc https://eth-mainnet.example.com \
+ --rpc https://eth-mainnet.example.com \
--receiver 0xContractAddress \
--input 0xMethodSelector...
```
@@ -408,4 +448,4 @@ State files use JSON format with Ethereum quantity encoding:
## See Also
-- [run Command Documentation](src/run/README.md)
+- [The `run`, `tx` and `replay` command pages](../../docs/mega-evme/commands/)
diff --git a/bin/mega-evme/scripts/pack_blocks_fixture.py b/bin/mega-evme/scripts/pack_blocks_fixture.py
new file mode 100644
index 000000000..6c16ae049
--- /dev/null
+++ b/bin/mega-evme/scripts/pack_blocks_fixture.py
@@ -0,0 +1,55 @@
+#!/usr/bin/env python3
+"""Pack a block cache tree into the deterministic `tests/fixtures/blocks.tar.xz`.
+
+Usage: scripts/pack_blocks_fixture.py []
+
+`` holds `blocks/` and `codes/`.
+Members are regular files only, in sorted path order, in ustar with mode 0644, uid/gid 0, empty
+owner names and mtime 0; the tar is compressed with xz preset 9 extreme, single-threaded.
+Packing the same files therefore always gives the same bytes.
+`--check ` unpacks nothing: it repacks the archive's own members and requires the same bytes.
+"""
+import io
+import lzma
+import sys
+import tarfile
+from pathlib import Path
+
+DEFAULT_ARCHIVE = Path(__file__).resolve().parent.parent / "tests/fixtures/blocks.tar.xz"
+
+
+def pack(members):
+ """members: sorted list of (relative posix path, bytes)."""
+ raw = io.BytesIO()
+ with tarfile.open(fileobj=raw, mode="w", format=tarfile.USTAR_FORMAT) as tar:
+ for name, data in members:
+ info = tarfile.TarInfo(name)
+ info.size = len(data)
+ info.mode = 0o644
+ info.uid = info.gid = 0
+ info.uname = info.gname = ""
+ info.mtime = 0
+ tar.addfile(info, io.BytesIO(data))
+ filters = [{"id": lzma.FILTER_LZMA2, "preset": 9 | lzma.PRESET_EXTREME}]
+ return lzma.compress(raw.getvalue(), format=lzma.FORMAT_XZ, check=lzma.CHECK_CRC64, filters=filters)
+
+
+def main():
+ args = sys.argv[1:]
+ if args and args[0] == "--check":
+ archive = Path(args[1] if len(args) > 1 else DEFAULT_ARCHIVE)
+ with tarfile.open(archive, "r:xz") as tar:
+ members = [(m.name, tar.extractfile(m).read()) for m in tar.getmembers() if m.isfile()]
+ if pack(members) != archive.read_bytes():
+ sys.exit(f"{archive}: a repack of its members differs")
+ print(f"{archive}: repack is byte-identical")
+ return
+ root = Path(args[0])
+ out = Path(args[1]) if len(args) > 1 else DEFAULT_ARCHIVE
+ files = sorted(p for p in root.rglob("*") if p.is_file())
+ members = [(p.relative_to(root).as_posix(), p.read_bytes()) for p in files]
+ out.write_bytes(pack(members))
+ print(f"{out}: {len(members)} members, {out.stat().st_size} bytes")
+
+
+main()
diff --git a/bin/mega-evme/src/block/cmd.rs b/bin/mega-evme/src/block/cmd.rs
new file mode 100644
index 000000000..3c78654d9
--- /dev/null
+++ b/bin/mega-evme/src/block/cmd.rs
@@ -0,0 +1,344 @@
+//! `mega-evme replay --block`: replay whole blocks and compare them with the chain.
+
+use std::path::PathBuf;
+
+use clap::Args;
+use tracing::info;
+
+use super::{
+ inputs::BlockSource,
+ record::{records, BlockRecord, TxRecord},
+ satin,
+ state::{BlockState, ParentStateRpc},
+};
+use crate::{
+ common::{EvmeError, LimitsOverride, Result, RpcArgs},
+ engine::Engine,
+};
+
+/// Block replay configuration
+#[derive(Args, Debug, Clone, Default)]
+#[command(next_help_heading = "Block Replay Options")]
+pub struct BlockArgs {
+ /// Replay whole blocks instead of one transaction: `N`, or `N..M` for blocks N through M.
+ /// Each block runs on the engine its spec names: the one `--override.spec` forces, or the
+ /// one the chain's schedule gives at the block's timestamp.
+ #[arg(
+ long = "block",
+ value_name = "N[..M]",
+ value_parser = parse_block_range,
+ conflicts_with_all = [
+ "tx_hash", "dump_fixture", "trace", "dump", "gas_limit", "value", "input",
+ "input_file", "capture_file", "replay_file",
+ ],
+ )]
+ pub block: Option,
+
+ /// Block cache directory. A block is read from it when it is there, and a block fetched over
+ /// `--rpc` is written to it, with the state its replay read beyond the block's trace, so the
+ /// next replay of it is offline. Layout: `blocks//.json.zst` and
+ /// `codes//.bin`.
+ #[arg(long = "block-cache", value_name = "DIR", requires = "block")]
+ pub block_cache: Option,
+
+ /// Compare every replayed transaction (status, gas used, cumulative gas used, logs) and the
+ /// block's receipts root with the chain's, and exit with code 2 when a block differs.
+ #[arg(long = "verify", requires = "block")]
+ pub verify: bool,
+}
+
+/// An inclusive range of block numbers.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct BlockRange {
+ /// The first block.
+ pub from: u64,
+ /// The last block.
+ pub to: u64,
+}
+
+/// Parses `N` or `N..M`, with `M >= N`.
+pub fn parse_block_range(s: &str) -> std::result::Result {
+ let number = |part: &str| {
+ part.trim().parse::().map_err(|e| format!("invalid block number {part:?}: {e}"))
+ };
+ let (from, to) = match s.split_once("..") {
+ Some((from, to)) => (number(from)?, number(to)?),
+ None => (number(s)?, number(s)?),
+ };
+ if to < from {
+ return Err(format!("the range {s} ends before it starts"));
+ }
+ if from == 0 {
+ return Err("block 0 has no parent to replay it on".to_string());
+ }
+ Ok(BlockRange { from, to })
+}
+
+/// What a replay of blocks came to.
+#[derive(Debug, Default, Clone, PartialEq, Eq)]
+pub struct ReplaySummary {
+ /// Blocks replayed.
+ pub blocks: usize,
+ /// Blocks whose every transaction and receipts root match the chain.
+ pub matching: usize,
+ /// Blocks that could not be replayed, with why.
+ pub failed: Vec<(u64, String)>,
+}
+
+impl ReplaySummary {
+ /// The process exit code: 1 when a block could not be replayed, 2 when `verify` and a block
+ /// differs from the chain, 0 otherwise.
+ pub fn exit_code(&self, verify: bool) -> i32 {
+ if !self.failed.is_empty() {
+ 1
+ } else if verify && self.matching != self.blocks {
+ 2
+ } else {
+ 0
+ }
+ }
+}
+
+/// Replays `range` and prints a record per transaction and per block (`json`) or a line per
+/// block.
+pub async fn replay_blocks(
+ range: BlockRange,
+ args: &BlockArgs,
+ rpc_args: &RpcArgs,
+ bucket_capacities: &[(u32, u64)],
+ spec_override: Option<&str>,
+ limits_override: Option<&LimitsOverride>,
+ json: bool,
+) -> Result {
+ let (provider, chain_id) = if rpc_args.rpc_url.is_some() {
+ let (provider, chain_id) = rpc_args.build_lookup_provider().await?;
+ (Some(provider), Some(chain_id))
+ } else if args.block_cache.is_some() {
+ (None, None)
+ } else {
+ return Err(EvmeError::InvalidInput(
+ "'replay --block' needs '--block-cache ', '--rpc ', or both".to_string(),
+ ));
+ };
+ let forced_engine = spec_override.map(Engine::of_spec).transpose()?;
+ let source = BlockSource::new(args.block_cache.clone(), provider, chain_id);
+ let mut codes = source.code_store();
+ let mut summary = ReplaySummary::default();
+
+ for number in range.from..=range.to {
+ summary.blocks += 1;
+ let outcome = async {
+ let mut inputs = source.load(number, &mut codes).await?;
+ let engine = match forced_engine {
+ Some(engine) => engine,
+ None => Engine::of_block(inputs.chain_id, inputs.header.timestamp)?,
+ };
+ // The parent's timestamp is fetched only for a Satin block whose schedule makes the
+ // activation-block rule depend on it, so every other block replays from the cache.
+ if engine == Engine::Satin &&
+ inputs.parent_timestamp.is_none() &&
+ satin::needs_parent_timestamp(inputs.chain_id, inputs.header.timestamp)?
+ {
+ source.complete_parent_timestamp(&mut inputs).await?;
+ }
+ let fallback =
+ source.provider().and_then(|p| ParentStateRpc::new(p.clone(), number - 1));
+ let mut state =
+ BlockState::new(inputs.prestate.clone(), std::mem::take(&mut codes), fallback);
+ let executed = execute_block(
+ engine,
+ &inputs,
+ bucket_capacities,
+ spec_override,
+ limits_override,
+ &mut state,
+ );
+ let rpc_reads = state.fallback_reads;
+ let BlockState { prestate, codes: mut store, .. } = state;
+ let result = match executed {
+ Ok((executed, spec)) => {
+ if !inputs.from_cache || rpc_reads > 0 {
+ source.store(&inputs, &prestate, &mut store)?;
+ }
+ Ok(records(&inputs, &executed, engine, &spec, rpc_reads))
+ }
+ Err(e) => Err(e),
+ };
+ codes = store;
+ result
+ }
+ .await;
+ match outcome {
+ Ok((txs, block)) => {
+ if block.matches_chain {
+ summary.matching += 1;
+ }
+ print_block(&txs, &block, json);
+ }
+ Err(e) => {
+ let message = e.to_string();
+ if json {
+ println!(
+ "{}",
+ serde_json::json!({ "kind": "block", "block": number, "error": message })
+ );
+ } else {
+ println!("block {number} error: {}", crate::sanitize_terminal_text(&message));
+ }
+ summary.failed.push((number, message));
+ }
+ }
+ }
+ info!(?summary, "Block replay finished");
+ if !json {
+ println!(
+ "{} block(s) replayed: {} match the chain, {} differ, {} failed",
+ summary.blocks,
+ summary.matching,
+ summary.blocks - summary.matching - summary.failed.len(),
+ summary.failed.len()
+ );
+ }
+ Ok(summary)
+}
+
+/// Executes the block `inputs` describes on `engine` over `state`, returning what it produced
+/// and the spec it ran under: `spec_override` when given, otherwise, on the legacy engine, the
+/// spec the chain's schedule gives at the block's timestamp.
+///
+/// `limits_override` replaces the protocol limits a Satin block runs under; a legacy block,
+/// whose limits its spec fixes, is refused with one. Under a genesis file (`--genesis`) a block of
+/// another chain is refused first, and then a legacy block: the legacy engine runs a chain on its
+/// own table, which knows nothing of the file, and for a chain it does not know that is a spec no
+/// chain ran.
+pub fn execute_block(
+ engine: Engine,
+ inputs: &super::inputs::BlockInputs,
+ bucket_capacities: &[(u32, u64)],
+ spec_override: Option<&str>,
+ limits_override: Option<&LimitsOverride>,
+ state: &mut BlockState,
+) -> Result<(super::exec::ExecutedBlock, String)> {
+ crate::common::check_genesis_chain(inputs.chain_id)?;
+ match engine {
+ Engine::Satin => {
+ let executed = satin::execute(
+ inputs.chain_id,
+ &inputs.header,
+ inputs.parent_timestamp,
+ &inputs.transactions,
+ bucket_capacities,
+ limits_override,
+ state,
+ )?;
+ Ok((executed, mega_evm::MegaSpecId::SATIN.to_string()))
+ }
+ Engine::Legacy if limits_override.is_some() => Err(EvmeError::InvalidInput(format!(
+ "block {} runs on the legacy engine, whose limits its spec fixes; --override.limits \
+ applies to Satin only",
+ inputs.header.number
+ ))),
+ Engine::Legacy if crate::common::genesis_in_use() => Err(EvmeError::InvalidInput(format!(
+ "block {} runs on the legacy engine, which runs a chain on its own table; \
+ --genesis applies to Satin blocks only",
+ inputs.header.number
+ ))),
+ Engine::Legacy => run_legacy_block(inputs, bucket_capacities, spec_override, state),
+ }
+}
+
+#[cfg(feature = "legacy")]
+fn run_legacy_block(
+ inputs: &super::inputs::BlockInputs,
+ bucket_capacities: &[(u32, u64)],
+ spec_override: Option<&str>,
+ state: &mut BlockState,
+) -> Result<(super::exec::ExecutedBlock, String)> {
+ let spec =
+ super::legacy::resolve_spec(inputs.chain_id, inputs.header.timestamp, spec_override)?;
+ let executed = super::legacy::execute(
+ inputs.chain_id,
+ &inputs.header,
+ &inputs.transactions,
+ bucket_capacities,
+ spec_override,
+ state,
+ )?;
+ Ok((executed, spec))
+}
+
+#[cfg(not(feature = "legacy"))]
+fn run_legacy_block(
+ inputs: &super::inputs::BlockInputs,
+ _bucket_capacities: &[(u32, u64)],
+ _spec_override: Option<&str>,
+ _state: &mut BlockState,
+) -> Result<(super::exec::ExecutedBlock, String)> {
+ Err(EvmeError::InvalidInput(format!(
+ "block {} runs on the legacy engine, and this build runs Satin only (built without \
+ the `legacy` feature)",
+ inputs.header.number
+ )))
+}
+
+/// Prints a block's records: every record as a JSON line, or one line for the block.
+fn print_block(txs: &[TxRecord], block: &BlockRecord, json: bool) {
+ if json {
+ for tx in txs {
+ println!("{}", serde_json::to_string(tx).expect("a record serializes"));
+ }
+ println!("{}", serde_json::to_string(block).expect("a record serializes"));
+ return;
+ }
+ let verdict = if block.matches_chain {
+ "matches the chain".to_string()
+ } else {
+ let root = if block.receipts_root == block.chain_receipts_root {
+ ""
+ } else {
+ ", receipts root differs"
+ };
+ format!("{} of {} transactions differ{root}", block.differing, block.transactions)
+ };
+ let ledgers = block.satin.as_ref().map_or_else(String::new, |satin| {
+ let overridden = if satin.limits_override.is_some() { ", limits overridden" } else { "" };
+ format!(
+ " [regular {} state {} history {}{overridden}]",
+ satin.regular_gas, satin.state_gas, satin.history_gas
+ )
+ });
+ println!(
+ "block {} {} {} {} txs gas {}{ledgers} (chain {}) {verdict}",
+ block.block,
+ block.engine,
+ block.spec,
+ block.transactions,
+ block.gas_used,
+ block.chain_gas_used,
+ );
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn test_block_ranges_parse() {
+ assert_eq!(parse_block_range("7").unwrap(), BlockRange { from: 7, to: 7 });
+ assert_eq!(parse_block_range("7..9").unwrap(), BlockRange { from: 7, to: 9 });
+ assert!(parse_block_range("9..7").is_err());
+ assert!(parse_block_range("0").is_err(), "block 0 has no parent");
+ assert!(parse_block_range("x").is_err());
+ }
+
+ #[test]
+ fn test_exit_codes() {
+ let clean = ReplaySummary { blocks: 2, matching: 2, failed: vec![] };
+ assert_eq!(clean.exit_code(true), 0);
+ let differing = ReplaySummary { blocks: 2, matching: 1, failed: vec![] };
+ assert_eq!(differing.exit_code(true), 2);
+ assert_eq!(differing.exit_code(false), 0, "a difference is a failure only when verifying");
+ let failed = ReplaySummary { blocks: 2, matching: 1, failed: vec![(1, "x".into())] };
+ assert_eq!(failed.exit_code(true), 1);
+ }
+}
diff --git a/bin/mega-evme/src/block/exec.rs b/bin/mega-evme/src/block/exec.rs
new file mode 100644
index 000000000..7a2960ffc
--- /dev/null
+++ b/bin/mega-evme/src/block/exec.rs
@@ -0,0 +1,87 @@
+//! What either engine hands back for a block: plain data, the same shape from both.
+//!
+//! An executor takes the block's header fields, its transactions as EIP-2718 envelopes and a
+//! [`BlockState`](super::state::BlockState), and returns every transaction's receipt as its
+//! EIP-2718 encoding and the fields a comparison reads. No type of either revm line crosses.
+
+use alloy_primitives::{Bytes, Log};
+
+use mega_evm::ProtocolLimits;
+
+use crate::common::SatinReport;
+
+/// How an included transaction ended.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum ExecStatus {
+ /// It succeeded.
+ Success,
+ /// It reverted.
+ Revert,
+ /// It halted.
+ Halt,
+}
+
+impl ExecStatus {
+ /// The status's name in output.
+ pub const fn name(self) -> &'static str {
+ match self {
+ Self::Success => "success",
+ Self::Revert => "revert",
+ Self::Halt => "halt",
+ }
+ }
+}
+
+/// A receipt as the engine built it.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct ReceiptData {
+ /// The receipt's EIP-2718 encoding, which the receipts root is built from.
+ pub encoded: Bytes,
+ /// Whether the transaction succeeded.
+ pub success: bool,
+ /// The block's gas used after the transaction.
+ pub cumulative_gas_used: u64,
+ /// The logs.
+ pub logs: Vec,
+}
+
+/// What happened to one transaction of the block.
+#[derive(Debug, Clone)]
+pub enum TxResult {
+ /// The transaction ran and its receipt is in the block.
+ Included {
+ /// How it ended.
+ status: ExecStatus,
+ /// The halt reason or the decoded revert, when it did not succeed.
+ reason: Option,
+ /// Its receipt.
+ receipt: ReceiptData,
+ /// What Satin counted, on the Satin engine.
+ satin: Option,
+ },
+ /// The engine refused the transaction; it is not in the block and changed nothing.
+ Refused {
+ /// Why.
+ reason: String,
+ },
+}
+
+/// What executing a block produced.
+#[derive(Debug, Clone)]
+pub struct ExecutedBlock {
+ /// One result per transaction, in block order.
+ pub transactions: Vec,
+ /// The protocol limits a Satin block ran under when `--override.limits` replaced the
+ /// schedule's; `None` otherwise, and on the legacy engine.
+ pub limits_override: Option,
+}
+
+impl ExecutedBlock {
+ /// The receipts of the included transactions, in order.
+ pub fn receipts(&self) -> impl Iterator {
+ self.transactions.iter().filter_map(|tx| match tx {
+ TxResult::Included { receipt, .. } => Some(receipt),
+ TxResult::Refused { .. } => None,
+ })
+ }
+}
diff --git a/bin/mega-evme/src/block/inputs.rs b/bin/mega-evme/src/block/inputs.rs
new file mode 100644
index 000000000..dd34de4f6
--- /dev/null
+++ b/bin/mega-evme/src/block/inputs.rs
@@ -0,0 +1,412 @@
+//! Everything replaying a block needs from the chain, fetched over RPC or read from a block cache.
+//!
+//! Three requests describe a block: the block with its transactions, its receipts, and a
+//! `prestateTracer` trace from which its pre-state is built. The block cache keeps them per block
+//! as one zstd-compressed JSON file, `blocks//.json.zst`, with contract code split
+//! out into a shared store, `codes//.bin`.
+
+use std::path::{Path, PathBuf};
+
+use alloy_consensus::BlockHeader as _;
+use alloy_eips::Encodable2718;
+use alloy_primitives::{keccak256, Address, Bytes, Log, B256, U256, U64};
+use alloy_provider::Provider;
+use alloy_rpc_types_eth::Block;
+use op_alloy_rpc_types::Transaction;
+use serde::{Deserialize, Serialize};
+use serde_json::{json, Value};
+
+use super::state::{write_atomically, BlockPrestate, CodeStore};
+use crate::common::{EvmeError, OpProvider, Result};
+
+/// Version of the cached block format.
+const CACHE_VERSION: u32 = 1;
+
+/// zstd level cached blocks are written at.
+const CACHE_ZSTD_LEVEL: i32 = 3;
+
+/// A block's inputs as cached: the RPC responses for the block and its receipts, the pre-state
+/// built from its trace, and the parent block's timestamp.
+#[derive(Debug, Serialize, Deserialize)]
+pub struct CachedBlock {
+ /// Format version.
+ pub version: u32,
+ /// Chain the block belongs to.
+ pub chain_id: u64,
+ /// `eth_getBlockByNumber` result, with full transactions.
+ pub block: Value,
+ /// `eth_getBlockReceipts` result.
+ pub receipts: Value,
+ /// Pre-state; codes live in the code store.
+ pub prestate: BlockPrestate,
+ /// The parent block's timestamp, which decides whether a fork activates in the block.
+ ///
+ /// Kept once a replay of the block on Satin needed it; absent otherwise, and from an entry
+ /// written before the cache kept it.
+ #[serde(default, skip_serializing_if = "Option::is_none")]
+ pub parent_timestamp: Option,
+}
+
+/// The header fields block execution reads, in plain data.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct HeaderFields {
+ /// The block's hash.
+ pub hash: B256,
+ /// The block's number.
+ pub number: u64,
+ /// The block's timestamp.
+ pub timestamp: u64,
+ /// The block's beneficiary.
+ pub beneficiary: Address,
+ /// The block's gas limit.
+ pub gas_limit: u64,
+ /// The block's base fee.
+ pub base_fee: u64,
+ /// The block's difficulty.
+ pub difficulty: U256,
+ /// The block's `mixHash`, which is its `PREVRANDAO`.
+ pub mix_hash: B256,
+ /// The block's excess blob gas.
+ pub excess_blob_gas: u64,
+ /// The parent block's hash.
+ pub parent_hash: B256,
+ /// The parent beacon block root.
+ pub parent_beacon_block_root: Option,
+ /// The block's extra data.
+ pub extra_data: Bytes,
+ /// The block's receipts root.
+ pub receipts_root: B256,
+}
+
+/// A transaction of the block, as either engine takes it: its EIP-2718 envelope and its sender.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct TxInput {
+ /// The transaction's hash.
+ pub hash: B256,
+ /// The EIP-2718 encoding of the transaction.
+ pub envelope: Bytes,
+ /// The recovered sender.
+ pub sender: Address,
+}
+
+/// A log as the chain recorded it.
+#[derive(Debug, Clone, PartialEq, Eq, Deserialize)]
+pub struct ChainLog {
+ /// The emitting contract.
+ pub address: Address,
+ /// The topics.
+ pub topics: Vec,
+ /// The data.
+ pub data: Bytes,
+}
+
+/// The parts of a receipt a replay is compared with.
+#[derive(Debug, Clone, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ChainReceipt {
+ /// Hash of the transaction.
+ pub transaction_hash: B256,
+ /// Gas used as the chain recorded it.
+ pub gas_used: U64,
+ /// Cumulative gas used as the chain recorded it.
+ pub cumulative_gas_used: U64,
+ /// `0x1` for success.
+ #[serde(default)]
+ pub status: Option,
+ /// Logs as the chain recorded them.
+ #[serde(default)]
+ pub logs: Vec,
+}
+
+impl ChainReceipt {
+ /// Whether the transaction succeeded.
+ pub fn success(&self) -> bool {
+ self.status.is_some_and(|status| status == U64::from(1))
+ }
+
+ /// Whether `logs` are the chain's logs, in order.
+ pub fn logs_equal(&self, logs: &[Log]) -> bool {
+ self.logs.len() == logs.len() &&
+ self.logs.iter().zip(logs).all(|(chain, log)| {
+ chain.address == log.address &&
+ chain.topics == log.data.topics() &&
+ chain.data == log.data.data
+ })
+ }
+}
+
+/// A block ready to replay.
+#[derive(Debug)]
+pub struct BlockInputs {
+ /// Chain the block belongs to.
+ pub chain_id: u64,
+ /// The header fields execution reads.
+ pub header: HeaderFields,
+ /// The transactions, in block order.
+ pub transactions: Vec,
+ /// Receipts, in transaction order.
+ pub receipts: Vec,
+ /// The part of the parent block's state the block reads.
+ pub prestate: BlockPrestate,
+ /// The parent block's timestamp, when the cache holds it or a Satin replay of the block
+ /// fetched it ([`BlockSource::complete_parent_timestamp`]).
+ pub parent_timestamp: Option,
+ /// Whether the block cache holds these inputs as they are: false for inputs fetched over RPC,
+ /// wholly or in part, which the replay writes to the cache.
+ pub from_cache: bool,
+ /// The block and receipts responses as received, for writing the cache entry.
+ raw: (Value, Value),
+}
+
+impl BlockInputs {
+ /// Parses the RPC responses of a block into its inputs.
+ pub fn from_responses(
+ chain_id: u64,
+ block: Value,
+ receipts: Value,
+ prestate: BlockPrestate,
+ parent_timestamp: Option,
+ from_cache: bool,
+ ) -> Result {
+ let parsed: Block = serde_json::from_value(block.clone())
+ .map_err(|e| EvmeError::RpcError(format!("Malformed block: {e}")))?;
+ let chain_receipts: Vec = serde_json::from_value(receipts.clone())
+ .map_err(|e| EvmeError::RpcError(format!("Malformed receipts: {e}")))?;
+ let header = &parsed.header;
+ let number = header.number();
+ let fields = HeaderFields {
+ hash: header.hash,
+ number,
+ timestamp: header.timestamp(),
+ beneficiary: header.beneficiary(),
+ gas_limit: header.gas_limit(),
+ base_fee: header.base_fee_per_gas().unwrap_or_default(),
+ difficulty: header.difficulty(),
+ mix_hash: header.mix_hash().unwrap_or_default(),
+ excess_blob_gas: header.excess_blob_gas().ok_or_else(|| {
+ EvmeError::RpcError(format!("block {number} has no excess_blob_gas"))
+ })?,
+ parent_hash: header.parent_hash(),
+ parent_beacon_block_root: header.parent_beacon_block_root(),
+ extra_data: header.extra_data().clone(),
+ receipts_root: header.receipts_root(),
+ };
+ let raw_txs = block["transactions"].as_array().cloned().unwrap_or_default();
+ let transactions = parsed
+ .transactions
+ .into_transactions()
+ .zip(raw_txs)
+ .map(|(tx, raw)| tx_input(tx, &raw))
+ .collect::>>()?;
+ if transactions.is_empty() &&
+ block["transactions"].as_array().is_some_and(|t| !t.is_empty())
+ {
+ return Err(EvmeError::RpcError(format!(
+ "block {number} lists transaction hashes, not transactions"
+ )));
+ }
+ if chain_receipts.len() != transactions.len() {
+ return Err(EvmeError::RpcError(format!(
+ "block {number} has {} transactions but {} receipts",
+ transactions.len(),
+ chain_receipts.len()
+ )));
+ }
+ for (tx, receipt) in transactions.iter().zip(&chain_receipts) {
+ if tx.hash != receipt.transaction_hash {
+ return Err(EvmeError::RpcError(format!(
+ "block {number}: receipt of {} listed at the position of {}",
+ receipt.transaction_hash, tx.hash
+ )));
+ }
+ }
+ Ok(Self {
+ chain_id,
+ header: fields,
+ transactions,
+ receipts: chain_receipts,
+ prestate,
+ parent_timestamp,
+ from_cache,
+ raw: (block, receipts),
+ })
+ }
+
+ /// The cache entry of these inputs, with `prestate` as the block's pre-state.
+ fn to_cached(&self, prestate: &BlockPrestate) -> CachedBlock {
+ CachedBlock {
+ version: CACHE_VERSION,
+ chain_id: self.chain_id,
+ block: self.raw.0.clone(),
+ receipts: self.raw.1.clone(),
+ prestate: prestate.clone(),
+ parent_timestamp: self.parent_timestamp,
+ }
+ }
+}
+
+/// The EIP-2718 envelope and sender of `tx`, whose re-encoding must hash to the hash the chain
+/// reports for it: the envelope is rebuilt from the RPC object, and a field the object dropped
+/// would otherwise replay a different transaction.
+fn tx_input(tx: Transaction, raw: &Value) -> Result {
+ let reported: B256 = serde_json::from_value(raw["hash"].clone())
+ .map_err(|e| EvmeError::RpcError(format!("Malformed transaction hash: {e}")))?;
+ let recovered = tx.inner.inner;
+ let sender = recovered.signer();
+ let envelope = Bytes::from(recovered.inner().encoded_2718());
+ let hash = keccak256(&envelope);
+ if hash != reported {
+ return Err(EvmeError::RpcError(format!(
+ "transaction {reported} re-encodes to a different hash, {hash}"
+ )));
+ }
+ Ok(TxInput { hash, envelope, sender })
+}
+
+/// Where a block's inputs come from: a block cache, an RPC provider, or both, in that order.
+#[derive(Debug)]
+pub struct BlockSource {
+ cache_dir: Option,
+ provider: Option,
+ chain_id: Option,
+}
+
+impl BlockSource {
+ /// A source reading `cache_dir` first and `provider` (on chain `chain_id`) for what the
+ /// cache lacks.
+ pub fn new(
+ cache_dir: Option,
+ provider: Option,
+ chain_id: Option,
+ ) -> Self {
+ Self { cache_dir, provider, chain_id }
+ }
+
+ /// The code store the cache keeps codes in.
+ pub fn code_store(&self) -> CodeStore {
+ CodeStore::new(self.cache_dir.as_ref().map(|dir| dir.join("codes")))
+ }
+
+ /// The provider, when there is one.
+ pub fn provider(&self) -> Option<&OpProvider> {
+ self.provider.as_ref()
+ }
+
+ fn block_path(dir: &Path, number: u64) -> PathBuf {
+ dir.join("blocks").join((number / 10_000).to_string()).join(format!("{number}.json.zst"))
+ }
+
+ /// The inputs of block `number`, adding the codes its trace carries to `codes`.
+ pub async fn load(&self, number: u64, codes: &mut CodeStore) -> Result {
+ if let Some(dir) = &self.cache_dir {
+ let path = Self::block_path(dir, number);
+ if path.exists() {
+ let compressed = std::fs::read(&path)?;
+ let json = zstd::decode_all(compressed.as_slice())?;
+ let cached: CachedBlock = serde_json::from_slice(&json)
+ .map_err(|e| EvmeError::FixtureError(format!("{}: {e}", path.display())))?;
+ if cached.version != CACHE_VERSION {
+ return Err(EvmeError::FixtureError(format!(
+ "{}: cache version {} is not {CACHE_VERSION}",
+ path.display(),
+ cached.version
+ )));
+ }
+ if let Some(chain_id) = self.chain_id {
+ if cached.chain_id != chain_id {
+ return Err(EvmeError::FixtureError(format!(
+ "{}: cached for chain {}, the RPC serves chain {chain_id}",
+ path.display(),
+ cached.chain_id
+ )));
+ }
+ }
+ return BlockInputs::from_responses(
+ cached.chain_id,
+ cached.block,
+ cached.receipts,
+ cached.prestate,
+ cached.parent_timestamp,
+ true,
+ );
+ }
+ }
+ let (Some(provider), Some(chain_id)) = (&self.provider, self.chain_id) else {
+ return Err(EvmeError::Other(format!(
+ "block {number} is not in the block cache, and there is no '--rpc' to fetch it"
+ )));
+ };
+ let tag = format!("0x{number:x}");
+ let request = |method: &'static str, params: Value| async move {
+ provider
+ .raw_request::<_, Value>(method.into(), params)
+ .await
+ .map_err(|e| EvmeError::RpcError(format!("{method} of block {number}: {e}")))
+ };
+ let block = request("eth_getBlockByNumber", json!([tag, true])).await?;
+ if block.is_null() {
+ return Err(EvmeError::BlockNotFound(number));
+ }
+ let receipts = request("eth_getBlockReceipts", json!([tag])).await?;
+ let trace =
+ request("debug_traceBlockByNumber", json!([tag, { "tracer": "prestateTracer" }]))
+ .await?;
+ let prestate = BlockPrestate::from_block_trace(trace, codes)?;
+ BlockInputs::from_responses(chain_id, block, receipts, prestate, None, false)
+ }
+
+ /// Fetches the parent block's timestamp `inputs` lack, over RPC, and marks the inputs to be
+ /// written back to the cache with it; without a provider, leaves them as they are.
+ ///
+ /// Only a block that runs on Satin under a schedule that makes the answer depend on it needs
+ /// the timestamp ([`needs_parent_timestamp`](super::satin::needs_parent_timestamp)), so the
+ /// caller asks for it then and only then: a block another engine runs, or one no parent could
+ /// make an activation block, replays from what the cache holds.
+ pub async fn complete_parent_timestamp(&self, inputs: &mut BlockInputs) -> Result<()> {
+ if inputs.parent_timestamp.is_some() {
+ return Ok(());
+ }
+ if let Some(timestamp) = self.parent_timestamp(inputs.header.number).await? {
+ inputs.parent_timestamp = Some(timestamp);
+ inputs.from_cache = false;
+ }
+ Ok(())
+ }
+
+ /// The timestamp of block `number`'s parent, over RPC; `None` without a provider, or for
+ /// block 0, which has no parent.
+ async fn parent_timestamp(&self, number: u64) -> Result