Retrospective LLM-Based Complexity Evaluations

EIP complexity assessment

EIP-7928: Block-Level Access Lists

Assessed in Amsterdam / Glamsterdam. The score describes the EIP text available at the assessment cutoff, not the EIP as it stands today.

RetrospectiveAmsterdam / GlamsterdamAssessment cutoff 2025-07-31Included by cutoffLayers: execution
LLM Completescore 41
Human Completescore 29 · Checklist revision 1· merged checklist

Evaluated on: · Spec revision: 2025-07-31 · 59be937534

Scope at the cutoff. At this revision, EIP-7928 adds a mandatory Block-Level Access List (BAL). The BAL is an SSZ structure carried in the block body and committed to by a new `bal_hash` header field. It records every address accessed during block execution, sorted, along with storage writes (slot → [tx_index → new value]), read-only storage keys, and post-transaction balance, nonce and code values, each indexed by transaction. It also covers changes made by withdrawals and by system contracts (EIP-2935, EIP-4788, EIP-7002, EIP-7251). Block validation re-executes the block, builds the BAL from the gathered accesses (with reference to EIP-2929 accessed sets), and requires its hash to equal `bal_hash`. Any missing or extra entry makes the block invalid. Gas, opcode and transaction semantics are not changed.

41HighHigh
Evaluator
LLMChecklist v3
Confidence
Medium
Under-specified at assessment cutoff
Yes — 8 criteria affected
Plausible range
35–45 (High)
Assessment cutoff
2025-07-31 · EIP revision 59be937534 (2025-07-31)
Score bands · Checklist revision 3
  • Low <12
  • Medium 12–22
  • High ≥23

28 criteria scored 0–3 (4 in exceptional cases; cross-EIP interactions is uncapped); nominal maximum 84.

Complexity profile

Each segment is one criterion's contribution to the LLM total. Hover or focus a segment for its score and rationale.

Top complexity drivers

  1. Cross-EIP interactions4
  2. State-access ordering within opcode execution3
  3. New block / header fields3
  4. Encoding changes (RLP/SSZ)3

Under-specified at assessment cutoff: Yes

The EIP text available at the assessment cutoff left material behavior unresolved. The affected criteria and the plausible total range record that uncertainty.

Why: The revision contradicts itself on the transaction index for system-contract and withdrawal changes, and records pre-transaction system calls with the post-transaction index (twice). It does not say whether reverted-frame accesses, precompiles pre-warmed by EIP-2929, or unused EIP-2930 entries are included. The hash function, header field position and Engine API carriage are undefined. Several storage-read and code-change rules are vague or cannot express multiple changes. The worked example is internally inconsistent.

Unresolved questions at the cutoff (10)
  • Is the system-contract and withdrawal transaction index transaction_count or transaction_count + 1, and how are pre-transaction system calls (EIP-2935, EIP-4788) distinguished from post-transaction ones (EIP-7002, EIP-7251)?
  • Does process_system_contracts being called twice produce duplicate StorageChange entries?
  • Are accesses in reverted or out-of-gas frames included in the BAL, given that EIP-2929 sets revert with scope?
  • Are precompiles, tx.sender/tx.to and EIP-2930 access-list entries that are never actually touched included?
  • What is compute_bal_hash (keccak of the SSZ bytes vs hash_tree_root), and where in the header does bal_hash sit?
  • How are multiple code changes to one account in a block encoded when MAX_CODE_CHANGES = 1?
  • What does 'Slots in pre-state but not written' mean for storage_reads?
  • Is a balance that changes and then returns to its pre-transaction value within a transaction recorded? Is a zero-tip coinbase recorded?
  • Are the MAX_TXS / MAX_SLOTS / MAX_ACCOUNTS bounds enforced as block-validity rules?
  • How is the BAL carried over the Engine API?
Notable ambiguities noted by the assessor (6)
  • The Edge Cases text says the system-contract index is transaction_count + 1, but process_system_contracts passes len(block.transactions) and comments 'tx_index = transaction_count'.
  • The EIP-2935 address is given as 0x…0001 with slot (number-1) % 8191, and the EIP-4788 slots use % 8192. These cannot be checked against the prerequisite EIPs, which are not supplied.
  • The EIP-7702 hyperlink points to eip-7792.md (Verifiable logs). EIP-7792 is not treated as a scheduled interaction.
  • build_bal_from_accesses sorts storage_reads with key=lambda x: x.slot although the elements are raw keys. The example's storage_reads is bytes, not a list, and the example balance hex values do not match the stated ETH amounts.
  • Nonce changes are listed for 'contracts that performed a successful CREATE', so failed CREATEs that still bump the nonce are ambiguous.
  • 'Clients MAY invalidate immediately if any transaction exceeds declared state' is optional behaviour whose observable effect on the final validity outcome is unclear.

Criterion breakdown

EIP-7928 Amsterdam / Glamsterdam: LLM criterion scores and rationale
CriterionScoreWhy this scoreEvidence / uncertainty
Cross-EIP interactionsExceptional4The BAL's expected contents depend jointly on EIP-2929/EIP-2930 access semantics, four system-contract EIPs and EIP-7702 delegation. Shared block vectors need coordinated scenarios that combine these, so level 3.
  • eip.md · process_system_contracts Couples the BAL to EIP-7002, EIP-7251, EIP-2935 and EIP-4788 system-call storage diffs.
  • eip.md · State Transition Function — "per EIP-2929" BAL contents are tied to EIP-2929 access tracking.
  • eip.md · SSZ Data Structures — "EIP-7702 authorities" Nonce (and implicitly code) changes from EIP-7702 authorizations must be recorded.
  • eip.md · Motivation — EIP-2930 EIP-2930 access-list pre-warming feeds into EIP-2929 sets.
Confidence: Medium
Uncertainty: EIP-7792 is linked only via an apparent mislink for EIP-7702 and is not counted.
Interacting EIPs: EIP-2929, EIP-2930, EIP-2935, EIP-4788, EIP-7002, EIP-7251, EIP-7702
State-access ordering within opcode executionUnder-specified3The rubric counts which accesses enter the block-level access list. This EIP creates a block-wide definition of a recordable access that applies to every state-accessing opcode class: SLOAD/SSTORE, BALANCE/EXT*, CALL-family, CREATE/CREATE2 and SELFDESTRUCT. Each needs cases for cold/warm, reverted vs successful frames, out-of-gas before or after access, and static vs non-static calls. That is a definition change across operations, so level 3.
  • eip.md · SSZ Data Structures — "Addresses accessed without state changes (e.g., STATICCALL targets, BALANCE opcode targets)" Every address accessed during block execution must enter the BAL, including targets of read-only opcodes.
  • eip.md · Edge Cases — "Accessed but unchanged: Include with empty changes (EXTCODEHASH, EXTCODESIZE, BALANCE targets)" Defines BAL-recordable accesses across the EXT*, BALANCE, CALL-family and SELFDESTRUCT opcode classes.
  • eip.md · State Transition Function — "comparing execution-gathered accesses (per EIP-2929) with the BAL" Ties BAL inclusion to EIP-2929 access tracking, which is transaction-scoped and reverts with its scope.
  • supporting/eip-2929.md · Specification — "if a scope reverts, the access lists should be in the state they were in before that scope was entered" The baseline access sets revert with the scope and are pre-seeded with precompiles, sender and to. How these map to BAL inclusion determines the expected results.
Confidence: Medium
Uncertainty: Gas-charge ordering itself does not change. A reading that the EIP only reuses EIP-2929 sets would support level 2.
New block / header fields3New execution-header member (bal_hash) and new block-body element, so level 3.
  • eip.md · Block Structure Modification — "class Header: ... bal_hash: Hash32" Adds bal_hash to the execution header and a BlockAccessList to the block body.
Confidence: High
Encoding changes (RLP/SSZ)3The header schema, block body schema and a new SSZ BAL schema are all introduced, so level 3.
  • eip.md · SSZ Data Structures New SSZ BlockAccessList, AccountChanges, SlotChanges and change containers.
  • eip.md · Block Structure Modification — "bal_hash: Hash32" The header RLP gains a field.
  • eip.md · Rationale — "SSZ BAL embedded as opaque bytes in RLP block" The block body RLP gains an SSZ-encoded element.
Confidence: High
Block syncing changes3There are multiple new decode and validation rules: header field, body BAL decoding, SSZ list bounds and ordering. At least one, bal_hash equality with the execution-derived BAL, is complex, so level 3.
  • eip.md · Block Structure Modification New header field and new block body element must be decoded.
  • eip.md · SSZ Data Structures — Ordering requirements Structural ordering rules for addresses, storage keys and transaction indices.
  • eip.md · State Transition Function — bal_hash check The bal_hash check depends on executing the full block against state.
Confidence: High
New test-framework primitivesUnder-specified3The framework's shared block model must include an SSZ BAL body element and the bal_hash header field. That changes how every blockchain-test family builds blocks, and invalid-BAL modifiers and BAL expectation abstractions are also needed. This is a shared representation that changes construction across families, so level 3.
  • eip.md · SSZ Data Structures A nested SSZ BAL (account → field → tx_index → change) must be represented, expected and compared.
  • eip.md · State Transition Function — "Missing or spurious entries invalidate the block" Every block must carry a correct BAL, which affects block construction in all blockchain-test families.
Confidence: Medium
Uncertainty: If the BAL is produced purely by the client or t8n and checked only in BAL-specific tests, level 2 would suffice.
Security risksUnder-specified3A shared validation and trust invariant (BAL correctness) is consumed by block validation, parallel prefetch and execution, and executionless sync. Malicious BALs (missing, spurious, mis-ordered or with wrong values) need coordinated adversarial scenarios across these components, so level 3.
  • eip.md · State Transition Function — "Missing or spurious entries invalidate the block." Block validity now depends on exact equality between the BAL and execution.
  • eip.md · Motivation — "State reconstruction without executing transactions" Syncing nodes may apply BAL diffs without execution, which trusts the BAL.
  • eip.md · Rationale — "Post-execution values enable state reconstruction during sync without individual proofs" Sync, parallel execution and validation components all rely on the BAL invariant.
Confidence: Medium
Uncertainty: If clients only validate the BAL after full sequential execution, the risk narrows to level 2.
Performance risks3The change couples execution tracking (per-transaction diffs, including up to 24 KB code entries), SSZ encoding and hashing, block size and propagation, and parallel IO scheduling. Adversarial blocks that maximize accounts, slots or balance changes per gas need integrated stress testing across execution, networking and validation subsystems. Level 3.
  • eip.md · Block Size Considerations — "Worst-case (36m gas): ~0.93 MiB" The BAL adds un-gas-metered block size that scales with accesses.
  • eip.md · Asynchronous Validation Claims verification runs alongside parallel IO/EVM without delaying processing, which is a new assumption to validate.
  • eip.md · Security Considerations — Validation Overhead / Block Size Validation overhead and propagation impact are acknowledged.
Confidence: Medium
Uncertainty: The supplied size figures come from historical analysis. Worst-case adversarial composition is not quantified.
Edge/boundary conditions3Several boundary-sensitive mechanisms are introduced: list and size limits, MAX_CODE_CHANGES = 1, and the zero-value balance rule. Storage classification is an elevated matrix: whether the slot is read, whether the written value equals the original, zero vs non-zero, reverted vs committed frames, and multiple transactions touching the same slot all interact to decide between storage_changes, storage_reads and absence. Level 3.
  • eip.md · SSZ Data Structures — MAX_TXS, MAX_SLOTS, MAX_ACCOUNTS, MAX_CODE_SIZE, MAX_CODE_CHANGES = 1, TxIndex = uint16, Balance = uint128 New SSZ list and type bounds, including at most one code change per account per block.
  • eip.md · SSZ Data Structures — storage writes vs reads Classification depends on pre-value, post-value, same-value writes, zeroing and read-then-write.
  • eip.md · Edge Cases — "Zero-value transfers: Include address, omit from balance_changes" Zero vs non-zero value transfers produce different BAL entries.
Confidence: Medium
Uncertainty: Several of these outcomes are also under-specified (see UNSP).
Unspecified behavior requiring cross-client consensus3Which addresses and slots were accessed — including reverted frames, out-of-gas paths and pre-warmed sets — was previously unobservable and now becomes consensus-visible. The supplied rules give competing interpretations and outright contradictions (system/withdrawal transaction index, duplicate recording, hash function), so agreement on shared rules and re-baselining across opcode, system-call and withdrawal families are needed. Level 3.
  • eip.md · Edge Cases — "recorded with transaction index transaction_count + 1" Contradicts the code, which uses len(block.transactions) and the comment "tx_index = transaction_count". Pre-transaction system calls get the same index as post-transaction changes.
  • eip.md · validate_bal — process_system_contracts called twice Records EIP-2935/EIP-4788 writes twice with the same index. Withdrawals share the index too.
  • eip.md · State Transition Function — "per EIP-2929" Does not say whether reverted-frame accesses, precompiles pre-warmed by EIP-2929, or unused EIP-2930 entries are included.
  • supporting/eip-2929.md · Specification — accessed_addresses initialized to include the set of all precompiles Literal reuse would put all precompiles into every BAL.
  • eip.md · SSZ Data Structures — "Slots in pre-state but not written"; MAX_CODE_CHANGES = 1 Vague storage-read rule. Multiple code changes per account per block have no encoding.
  • eip.md · State Transition Function — compute_bal_hash The hash function is undefined, and so is the header field position.
Confidence: High
Uncertainty: Some apparent conflicts with EIP-2935/EIP-4788 addresses cannot be verified because those EIPs are not supplied.
Engine API changesUnder-specified2A new body element and header commitment would need to be carried in the execution payload exchanged with the CL, probably as multiple fields (BAL, bal_hash). Given the evidence gap, level 2 is the best-supported estimate.
  • eip.md · Block Structure Modification — "The block body includes a BlockAccessList" A new body element and header field must travel with execution payloads. The text specifies no Engine API changes.
Confidence: Low
Uncertainty: The supplied revision is silent on the Engine API. The actual change could range from one field to a new versioned endpoint plus fields (1–3).
Transition-tool interface changesUnder-specified2t8n must compute and output the block access list, and possibly its hash. That needs a new mechanism: block-wide access tracking across system calls, transactions and withdrawals. Treating the BAL and its hash as one semantic output gives level 2: a new mechanism with at most one field.
  • eip.md · State Transition Function — validate_bal / build_bal_from_accesses The state transition must collect per-transaction accesses, withdrawal changes and system-contract changes into a BAL and compare its hash.
  • eip.md · Block Structure Modification New header field bal_hash and a BAL body element.
Confidence: Medium
Uncertainty: No t8n specification is supplied. If the BAL, bal_hash and a BAL input for validation count as separate fields, the score would be 3.
Patterns affecting pre-existing testsUnder-specified2Gas and execution results of baseline tests are unchanged. Tests that hand-construct block RLP or headers need reworked inputs: header-validation, RLP block-structure and invalid-block families, plus any fixtures with fixed block hashes. That is localized rework in several families without a common behavioral rewrite, so level 2. Adding the BAL assertion to ordinary tests is scored under INV.
  • eip.md · Block Structure Modification — "bal_hash: Hash32" A new header field and a new body element change how every block is constructed and change block hashes.
  • eip.md · Rationale — "SSZ BAL embedded as opaque bytes in RLP block" The block RLP layout changes.
Confidence: Medium
Uncertainty: Without a supplied test suite, the breadth of hand-crafted block fixtures is estimated.
New invariant on pre-existing tests2Every baseline blockchain test in the target fork must additionally produce and check a correct BAL/bal_hash. The rubric caps a universal assertion at level 2 unless pre-fork vectors must also be re-derived, and nothing supplied shows that.
  • eip.md · State Transition Function — "The BAL MUST be complete and accurate. Missing or spurious entries invalidate the block." Every block in the fork must carry a correct BAL and bal_hash, which is a new output checked for every executed block.
Confidence: High
Modified system contracts1Contract rules are unchanged. Only an indirect output convention changes: system-call diffs must be recorded in the BAL under a special index. Level 1.
  • eip.md · Edge Cases — "System Contract caused changes: Are recorded with transaction index transaction_count + 1" System-contract storage diffs gain a new recorded output convention.
  • eip.md · process_system_contracts Storage diffs of the EIP-7002, EIP-7251, EIP-2935 and EIP-4788 contracts are recorded in the BAL. Their rules are not changed.
Confidence: Medium
Uncertainty: The listed addresses and slots for EIP-2935 (0x…01, %8191) and EIP-4788 may conflict with those EIPs, which are not supplied. That is treated as an evidence gap or ambiguity, not as a modification.
New or modified transaction validity mechanismsUnder-specified1Transaction eligibility rules and intrinsic gas are unchanged. The only effect is an implicit bound from the BAL list limits on the transactions or state a block can hold, which is a local bound, so level 1.
  • eip.md · SSZ Data Structures — "MAX_TXS = 30_000", "TxIndex = uint16" BAL list bounds implicitly cap the transactions, slots and accounts a valid block can carry.
  • eip.md · State Transition Function — "Clients MAY invalidate immediately if any transaction exceeds declared state." Optional early invalidation of the block when a transaction exceeds declared state. Block validity, not transaction eligibility, is affected.
Confidence: Low
Uncertainty: The text does not say whether the MAX_* limits are enforced as block validity rules. Plausible range 0–2.
Show 12 zero-score criteria
Zero-score criteria (Checklist revision 3)
CriterionScoreWhy this scoreEvidence / uncertainty
Added opcodes0Level 0.
  • eip.md · Specification No new instruction is defined.
Modified opcodes0Access recording alone does not count as a semantic change, so level 0.
  • eip.md · Edge Cases Opcodes are only observed for BAL recording. Their stack, state, return and halt semantics are unchanged.
Added precompiles0Level 0.
  • eip.md · Specification No precompile is introduced.
Modified precompiles0Level 0.
  • eip.md · Specification No precompile semantics or gas change.
Uncertainty: Whether precompile accesses appear in the BAL is an UNSP issue, not a precompile change.
Added system contracts0No new system contract, so level 0.
  • eip.md · process_system_contracts Only existing system contracts (EIP-7002, EIP-7251, EIP-2935, EIP-4788) are tracked. No new contract is introduced.
EVM Gas rule changes0No execution-gas accounting rule changes, so level 0.
  • eip.md · Specification The specification adds a header field, an SSZ BAL and BAL validation. It defines no gas charge, metering change or limit, and the BAL size is not charged gas.
Blob gas accounting changes0No blob-gas changes, so level 0.
  • eip.md · Specification Nothing in the specification concerns blobs or blob gas.
State gas accounting changes0No state-gas accounting changes, so level 0.
  • eip.md · Specification No state-byte cost, state-gas budget or spill rule is introduced.
New EVM gas refund0No new refund mechanism, so level 0.
  • eip.md · Edge Cases — "Gas refunds: Final balance of sender recorded after each transactions" Existing refunds are only reflected in the recorded balances. No new refund mechanism is added.
New transaction types0Level 0.
  • eip.md · Specification No new transaction envelope.
New fork activation mechanism0No activation-specific state transition, so level 0.
  • eip.md · Backwards Compatibility Only requires a hard fork for the structural change. No state migration or code installation.
CryptographyUnder-specified0Only a commitment to a new structure is added, presumably with an existing hash primitive. Changed hashed bytes belong under encoding, so level 0.
  • eip.md · State Transition Function — "assert block.bal_hash == compute_bal_hash(computed_bal)" A commitment hash over the BAL. compute_bal_hash is not defined.
  • eip.md · Rationale — "SSZ encoding: Enables efficient Merkle proofs" Hints at SSZ merkleization but does not specify it.
Uncertainty: The hash function is unspecified. If SSZ hash_tree_root is required, which the EL baseline does not use, the score could be 1.
Assessment provenance
Assessed EIP revision
ethereum/EIPs@59be937534 EIPS/eip-7928.md committed 2025-07-31 · information cutoff 2025-07-31T16:00:14Z
Current master · File history · blob 23900781a2 · sha256 c1973b06017a
Rubric
Checklist revision 3 · ethspecs/pm@fe2f793b03
Evaluator
Opus 5.5 (claude-opus-5-5) at high effort, one tool-less call per EIP · isolation bubblewrap_claude_p_no_tools_v1
Source record
Frozen research record research/tasks/10-opus-v3-reassessment/retrospective/outputs/assessments/amsterdam/eip-7928.yaml · sha256 70712dc1ad41
Supporting documents supplied with the EIP
supporting/eip-2929.md, supporting/eip-2930.md, supporting/eip-7792.md

Evaluated on: Not recorded · Spec revision: 2026-04-20 · 645099785a

29HighHigh
Evaluator
HumanChecklist v1
Confidence
Not recorded
Under-specified at assessment cutoff
Not recorded in the checklist
Checklist published
2026-05-12 · EIP at 645099785a
Score bands · Checklist revision 1
  • Low <10
  • Medium 10–19
  • High ≥20

24 criteria scored 0–3 (4 in exceptional cases; cross-EIP interactions is uncapped); nominal maximum 72.

Complexity profile

Each segment is one criterion's contribution to the Human total. Hover or focus a segment for its score and rationale.

Top complexity drivers

  1. EVM Gas rule changes3
  2. New block / header fields3
  3. Engine API changes3
  4. Security risks3

Criterion breakdown

EIP-7928 Amsterdam / Glamsterdam: Human criterion scores and rationale
CriterionScoreWhy this scoreNotes
EVM Gas rule changes3No new gas schedule, but the EIP imposes a hard pre-state / post-state validation ordering on every state-accessing opcode (`BALANCE`, `EXT*`, `*CALL`, `CREATE*`, `SLOAD`, `SSTORE`, `SELFDESTRUCT`). Gas-charge sites had to be re-ordered across the spec because state was being accessed before gas was charged; off-by-one boundaries determine whether an address appears in the BAL, so the rule change cascades into existing gas tests across multiple forks.—
New block / header fields3New `block_access_list_hash` (Hash32) on the header; `blockAccessList` carried out-of-header via the Engine API.—
Engine API changes3Multiple fields **and** multiple new endpoints: `ExecutionPayloadV4` adds `blockAccessList`; new `engine_newPayloadV5`, `engine_getPayloadV6`, `engine_getPayloadBodiesByHashV2`, `engine_getPayloadBodiesByRangeV2` returning `ExecutionPayloadBodyV2`. EL must also retain BALs ≥ weak-subjectivity period.—
Security risks3The BAL elevates **every state-access check** — not just state writes — into consensus-critical territory. Whether an account or slot appears in the BAL depends on whether the caller had enough gas to *touch* it (cold/warm cache, account existence, 7702 delegation load, static-context check, value-transfer gas), and whether ambient artefacts like the coinbase or precompiles are deemed "touched" under fee-burning, empty-block, zero-tip, and selfdestruct-to-self scenarios. Any client that mis-orders a gas check vs. a state observation, mis-classifies a touch, or leaks cross-block precompile state diverges from the block-hash-bound BAL and breaks consensus. This is a substantial expansion of the consensus surface that interacts with multiple critical components (EVM gas accounting, EIP-2929 warm/cold tracking, EIP-6780 selfdestruct semantics, EIP-7702 delegation resolution, system-contract handling) and warrants extensive review and fuzzing.—
Performance risks3The BAL adds ~70 KiB/block of propagation overhead and is interwoven with execution — it cannot be benchmarked in isolation because validation requires re-deriving the BAL during the state transition. Builder behavior interacts with intra-tx coalescing, cross-frame shadowing, net-zero filtering, and the `R_remaining * 2000` gas-budget feasibility check. Benchmark suites under `tests/benchmark/stateful/eip7928_block_level_access_lists/` and `tests/benchmark/compute/eip7928_block_level_access_lists/` were added.—
Edge/boundary conditions3An elevated number of cases is required. Per `test_cases.md` the BAL implementation drove gas off-by-one boundary tests at every state-access opcode (cold vs warm × OOG-before-target-access / OOG-after-target-access / success-minus-1 / success). Add: net-zero storage filtering (intra-tx coalescing, cross-frame shadowing, nested DELEGATECALL net-zero), CREATE/CREATE2 collisions, same-tx create+SELFDESTRUCT, 7702 invalid-nonce/invalid-chain-id, static-context filtering across all call opcodes, empty-block coinbase, zero-tip coinbase, system-address surplus filtering, RIPEMD-160 cross-block state leak, lexicographic byte-ordering endian traps.—
Cross-EIP interactions3Strong interdependencies, with existing test vectors actively redesigned: EIP-2929 (warm/cold) drives the gas-boundary cliffs that gate BAL inclusion; EIP-2930 listed-but-untouched entries are explicitly excluded; EIP-1559 coinbase tipping vs. burned base fee determines coinbase inclusion; EIP-6780 changes selfdestruct persistence semantics that the BAL must mirror; EIP-7702 delegation creates a two-level access model (target vs. delegated target) with multiple OOG boundaries and authorization-failure cases; EIP-4895 withdrawals are credited at `index=n+1` with no EVM execution; EIP-2935, EIP-4788, EIP-7002, EIP-7251 each require system-contract storage diff and cross-index handling; EIP-1153 transient storage must be explicitly *excluded*; EIP-214 static-context restrictions must fire before BAL inclusion.—
Modified system contracts2No direct modification, but **major** indirect effects on every system contract whose storage diffs/queue dequeues must now be recorded: EIP-2935 (HISTORY_STORAGE_ADDRESS), EIP-4788 (BEACON_ROOTS_ADDRESS), EIP-7002 (withdrawal requests), EIP-7251 (consolidation requests). Cross-index semantics (pre-execution `index=0`, post-execution `index=n+1`), partial vs. clean sweep for 7002/7251 queues, and `SYSTEM_ADDRESS` exclusion-unless-touched all required new tests.—
Block syncing changes2A single complex RLP validation mechanism is introduced: the BAL itself, whose sub-rules include hash binding to the header, lexicographic address ordering, ascending `block_access_index` per change list, uniqueness per `(address, slot)`, mutual exclusion between `storage_changes` and `storage_reads`, `bal_items <= block_gas_limit // ITEM_COST`, and `SYSTEM_ADDRESS` exclusion unless touched. The three new block exceptions (`INVALID_BLOCK_ACCESS_LIST`, `INVALID_BAL_HASH`, `BLOCK_ACCESS_LIST_GAS_LIMIT_EXCEEDED`) all stem from this single validator.—
Transition-tool interface changes2A single new mechanism — the BAL builder/validator wired into the t8n (`block_access_lists.py`, `BlockAccessListBuilder`, `hash_block_access_list`, `validate_block_access_list_gas_limit`) — surfaces one new payload output (`blockAccessList` on `ExecutionPayloadV4`). The `block_access_list_hash` on the header is **not an independent field**: it is fully determined as `keccak256(rlp(BAL))` and carries no information not already present in the BAL itself. It is a Merkle/checksum binding, comparable to `transactionsRoot` vs. the transaction list — counting it as a second "new field" would double-count one piece of information. So in t8n terms this is "a new mechanism" (singular) producing one new output, not "multiple new fields **and** a new mechanism" (the 3 bucket). Per the anchor's footnote, the t8n must additionally be fork-aware (Amsterdam-only activation), which warrants special consideration regardless of score.—
Patterns affecting pre-existing tests2A considerable subset of existing tests is affected, but the impact is concentrated in a contrived category: benchmarks and gas-boundary fixtures. BAL changes the cost surface (added per-block data, propagation overhead, builder/validator work) so pre-existing benchmarks no longer represent worst cases — new adversarial scenarios (fan-out reads, many-slot touches, deep delegation chains, large BAL-item counts approaching `block_gas_limit // ITEM_COST`) need to be researched and added, and the benchmarking framework needs new metrics for BAL size, generation cost, and validation cost. Existing OOG-boundary fixtures across forks need their warm/cold/touch assumptions re-verified under BAL inclusion semantics. Outside those categories, most pre-existing tests need no rework — Amsterdam-filled tests generate and validate a BAL automatically as a consensus artefact.—
Show 13 zero-score criteria
Zero-score criteria (Checklist revision 1)
CriterionScoreWhy this scoreNotes
Added opcodes0No rationale recorded.—
Modified opcodes0Final EVM semantics (gas charged, state changes, reverts) are unchanged. Only the observation order for BAL inclusion is constrained, which is a spec-framework concern, not a behavior change in the anchor's sense.—
Added precompiles0No rationale recorded.—
Modified precompiles0No rationale recorded.—
Added system contracts0No rationale recorded.—
Blob gas accounting changes0No rationale recorded.—
New EVM gas refund0No rationale recorded.—
New transaction types0No rationale recorded.—
New or modified transaction validity mechanisms0Transaction structure and intrinsic gas are unchanged.—
Encoding changes (RLP/SSZ)0No rationale recorded.—
New fork activation mechanism0No state mutation or pre-existing internal variable is modified at the activation block (the builder is initialized fresh per block).—
Engine API encoding changes0Still RLP — no new wire encoding format introduced at the Engine API layer beyond what is captured under "Encoding changes (RLP/SSZ)".—
Cryptography0Keccak-256 over RLP only — already covered.—
Assessment provenance
Assessed EIP revision
ethereum/EIPs@645099785a EIPS/eip-7928.md committed 2026-04-20
EIP master revision at the time of the human checklist commit; the checklist itself does not pin an EIP revision.
Current master · File history · blob f744fd9572 · sha256 304c0e626e12
Rubric
Checklist revision 1 · ethspecs/pm@d936bcb349
Evaluator
STEEL team · ethspecs/pm complexity_assessments
Source record
Merged checklist ethspecs/pm@6d744f3a80 complexity_assessments/EIPs/EIP-7928.md · committed 2026-05-12
blob 509dfc6013 · sha256 a8d3e39c4aa0
Research record
research/tasks/05c-amsterdam-human-assessment-alignment/inputs/human/eip-7928.yaml · sha256 b0ff6c50cbc4

The LLM applied checklist revision 3 and the human reviewers revision 1 to EIP-7928 in Amsterdam / Glamsterdam. Revision 3 phrases the same criteria more precisely; differences cover the 23 criteria both revisions share, and each total keeps its own revision. Δ is LLM minus Human.

LLM41High
Human29High
Δ total+12Same tier
Criteria16/23agree exactly · 5 differ by 1 · 2 differ by 2+
Confounded comparison. The human checklist evaluated the EIP as it stood when the checklist was written; the LLM evaluated the sealed historical revision. Input alignment: substantive drift; human hindsight exposure: high exposure.
Exposure evidence

The assessment explicitly relies on implementation files, permanent framework additions, benchmarks, planned and completed tests, spec churn, and bugs found by tests.

Substantive intervening revisions: Renames header field bal_hash->block_access_list_hash, specifies system-contract changes use tx_index = len(transactions) + 1, adds the rule that EIP-2930 access-list entries MUST NOT be auto-included, and extends the example. | Code changes now also track EIP-7702 delegation indicators. | Fixes system-contract tx_index from len(transactions) + 1 to len(transactions) throughout text, example and pseudocode. | Splits system-contract handling into pre-execution (tx_index = len(transactions)) and post-execution (len(transactions) + 1) phases, adds the explicit…

Complexity profiles side by side

LLM
Human

Largest disagreements: EVM Gas rule changes (−3), Encoding changes (RLP/SSZ) (+3), Block syncing changes (+1), Engine API changes (−1), Modified system contracts (−1)

Per-criterion scores, Human versus LLM, ordered by the size of the difference
CriterionLLMHumanΔAgreementRationale from each source
EVM Gas rule changes03−3Differ by 2+
Show rationale

LLM No execution-gas accounting rule changes, so level 0.

Human No new gas schedule, but the EIP imposes a hard pre-state / post-state validation ordering on every state-accessing opcode (`BALANCE`, `EXT*`, `*CALL`, `CREATE*`, `SLOAD`, `SSTORE`, `SELFDESTRUCT`). Gas-charge sites had to be re-ordered across the spec because state was being accessed before gas was charged; off-by-one boundaries determine whether an address appears in the BAL, so the rule change cascades into existing gas tests across multiple forks.

Encoding changes (RLP/SSZ)30+3Differ by 2+
Show rationale

LLM The header schema, block body schema and a new SSZ BAL schema are all introduced, so level 3.

Human No rationale recorded.

Modified system contracts12−1Differ by 1
Show rationale

LLM Contract rules are unchanged. Only an indirect output convention changes: system-call diffs must be recorded in the BAL under a special index. Level 1.

Human No direct modification, but **major** indirect effects on every system contract whose storage diffs/queue dequeues must now be recorded: EIP-2935 (HISTORY_STORAGE_ADDRESS), EIP-4788 (BEACON_ROOTS_ADDRESS), EIP-7002 (withdrawal requests), EIP-7251 (consolidation requests). Cross-index semantics (pre-execution `index=0`, post-execution `index=n+1`), partial vs. clean sweep for 7002/7251 queues, and `SYSTEM_ADDRESS` exclusion-unless-touched all required new tests.

New or modified transaction validity mechanisms10+1Differ by 1
Show rationale

LLM Transaction eligibility rules and intrinsic gas are unchanged. The only effect is an implicit bound from the BAL list limits on the transactions or state a block can hold, which is a local bound, so level 1.

Human Transaction structure and intrinsic gas are unchanged.

Block syncing changes32+1Differ by 1
Show rationale

LLM There are multiple new decode and validation rules: header field, body BAL decoding, SSZ list bounds and ordering. At least one, bal_hash equality with the execution-derived BAL, is complex, so level 3.

Human A single complex RLP validation mechanism is introduced: the BAL itself, whose sub-rules include hash binding to the header, lexicographic address ordering, ascending `block_access_index` per change list, uniqueness per `(address, slot)`, mutual exclusion between `storage_changes` and `storage_reads`, `bal_items <= block_gas_limit // ITEM_COST`, and `SYSTEM_ADDRESS` exclusion unless touched. The three new block exceptions (`INVALID_BLOCK_ACCESS_LIST`, `INVALID_BAL_HASH`, `BLOCK_ACCESS_LIST_GAS_LIMIT_EXCEEDED`) all stem from this single validator.

Engine API changes23−1Differ by 1
Show rationale

LLM A new body element and header commitment would need to be carried in the execution payload exchanged with the CL, probably as multiple fields (BAL, bal_hash). Given the evidence gap, level 2 is the best-supported estimate.

Human Multiple fields **and** multiple new endpoints: `ExecutionPayloadV4` adds `blockAccessList`; new `engine_newPayloadV5`, `engine_getPayloadV6`, `engine_getPayloadBodiesByHashV2`, `engine_getPayloadBodiesByRangeV2` returning `ExecutionPayloadBodyV2`. EL must also retain BALs ≥ weak-subjectivity period.

Cross-EIP interactions43+1Differ by 1
Show rationale

LLM The BAL's expected contents depend jointly on EIP-2929/EIP-2930 access semantics, four system-contract EIPs and EIP-7702 delegation. Shared block vectors need coordinated scenarios that combine these, so level 3.

Human Strong interdependencies, with existing test vectors actively redesigned: EIP-2929 (warm/cold) drives the gas-boundary cliffs that gate BAL inclusion; EIP-2930 listed-but-untouched entries are explicitly excluded; EIP-1559 coinbase tipping vs. burned base fee determines coinbase inclusion; EIP-6780 changes selfdestruct persistence semantics that the BAL must mirror; EIP-7702 delegation creates a two-level access model (target vs. delegated target) with multiple OOG boundaries and authorization-failure cases; EIP-4895 withdrawals are credited at `index=n+1` with no EVM execution; EIP-2935, EIP-4788, EIP-7002, EIP-7251 each require system-contract storage diff and cross-index handling; EIP-1153 transient storage must be explicitly *excluded*; EIP-214 static-context restrictions must fire before BAL inclusion.

Added opcodes000Agree
Show rationale

LLM Level 0.

Human No rationale recorded.

Modified opcodes000Agree
Show rationale

LLM Access recording alone does not count as a semantic change, so level 0.

Human Final EVM semantics (gas charged, state changes, reverts) are unchanged. Only the observation order for BAL inclusion is constrained, which is a spec-framework concern, not a behavior change in the anchor's sense.

Added precompiles000Agree
Show rationale

LLM Level 0.

Human No rationale recorded.

Modified precompiles000Agree
Show rationale

LLM Level 0.

Human No rationale recorded.

Added system contracts000Agree
Show rationale

LLM No new system contract, so level 0.

Human No rationale recorded.

Blob gas accounting changes000Agree
Show rationale

LLM No blob-gas changes, so level 0.

Human No rationale recorded.

New EVM gas refund000Agree
Show rationale

LLM No new refund mechanism, so level 0.

Human No rationale recorded.

New transaction types000Agree
Show rationale

LLM Level 0.

Human No rationale recorded.

New block / header fields330Agree
Show rationale

LLM New execution-header member (bal_hash) and new block-body element, so level 3.

Human New `block_access_list_hash` (Hash32) on the header; `blockAccessList` carried out-of-header via the Engine API.

New fork activation mechanism000Agree
Show rationale

LLM No activation-specific state transition, so level 0.

Human No state mutation or pre-existing internal variable is modified at the activation block (the builder is initialized fresh per block).

Transition-tool interface changes220Agree
Show rationale

LLM t8n must compute and output the block access list, and possibly its hash. That needs a new mechanism: block-wide access tracking across system calls, transactions and withdrawals. Treating the BAL and its hash as one semantic output gives level 2: a new mechanism with at most one field.

Human A single new mechanism — the BAL builder/validator wired into the t8n (`block_access_lists.py`, `BlockAccessListBuilder`, `hash_block_access_list`, `validate_block_access_list_gas_limit`) — surfaces one new payload output (`blockAccessList` on `ExecutionPayloadV4`). The `block_access_list_hash` on the header is **not an independent field**: it is fully determined as `keccak256(rlp(BAL))` and carries no information not already present in the BAL itself. It is a Merkle/checksum binding, comparable to `transactionsRoot` vs. the transaction list — counting it as a second "new field" would double-count one piece of information. So in t8n terms this is "a new mechanism" (singular) producing one new output, not "multiple new fields **and** a new mechanism" (the 3 bucket). Per the anchor's footnote, the t8n must additionally be fork-aware (Amsterdam-only activation), which warrants special consideration regardless of score.

Patterns affecting pre-existing tests220Agree
Show rationale

LLM Gas and execution results of baseline tests are unchanged. Tests that hand-construct block RLP or headers need reworked inputs: header-validation, RLP block-structure and invalid-block families, plus any fixtures with fixed block hashes. That is localized rework in several families without a common behavioral rewrite, so level 2. Adding the BAL assertion to ordinary tests is scored under INV.

Human A considerable subset of existing tests is affected, but the impact is concentrated in a contrived category: benchmarks and gas-boundary fixtures. BAL changes the cost surface (added per-block data, propagation overhead, builder/validator work) so pre-existing benchmarks no longer represent worst cases — new adversarial scenarios (fan-out reads, many-slot touches, deep delegation chains, large BAL-item counts approaching `block_gas_limit // ITEM_COST`) need to be researched and added, and the benchmarking framework needs new metrics for BAL size, generation cost, and validation cost. Existing OOG-boundary fixtures across forks need their warm/cold/touch assumptions re-verified under BAL inclusion semantics. Outside those categories, most pre-existing tests need no rework — Amsterdam-filled tests generate and validate a BAL automatically as a consensus artefact.

Security risks330Agree
Show rationale

LLM A shared validation and trust invariant (BAL correctness) is consumed by block validation, parallel prefetch and execution, and executionless sync. Malicious BALs (missing, spurious, mis-ordered or with wrong values) need coordinated adversarial scenarios across these components, so level 3.

Human The BAL elevates **every state-access check** — not just state writes — into consensus-critical territory. Whether an account or slot appears in the BAL depends on whether the caller had enough gas to *touch* it (cold/warm cache, account existence, 7702 delegation load, static-context check, value-transfer gas), and whether ambient artefacts like the coinbase or precompiles are deemed "touched" under fee-burning, empty-block, zero-tip, and selfdestruct-to-self scenarios. Any client that mis-orders a gas check vs. a state observation, mis-classifies a touch, or leaks cross-block precompile state diverges from the block-hash-bound BAL and breaks consensus. This is a substantial expansion of the consensus surface that interacts with multiple critical components (EVM gas accounting, EIP-2929 warm/cold tracking, EIP-6780 selfdestruct semantics, EIP-7702 delegation resolution, system-contract handling) and warrants extensive review and fuzzing.

Performance risks330Agree
Show rationale

LLM The change couples execution tracking (per-transaction diffs, including up to 24 KB code entries), SSZ encoding and hashing, block size and propagation, and parallel IO scheduling. Adversarial blocks that maximize accounts, slots or balance changes per gas need integrated stress testing across execution, networking and validation subsystems. Level 3.

Human The BAL adds ~70 KiB/block of propagation overhead and is interwoven with execution — it cannot be benchmarked in isolation because validation requires re-deriving the BAL during the state transition. Builder behavior interacts with intra-tx coalescing, cross-frame shadowing, net-zero filtering, and the `R_remaining * 2000` gas-budget feasibility check. Benchmark suites under `tests/benchmark/stateful/eip7928_block_level_access_lists/` and `tests/benchmark/compute/eip7928_block_level_access_lists/` were added.

Edge/boundary conditions330Agree
Show rationale

LLM Several boundary-sensitive mechanisms are introduced: list and size limits, MAX_CODE_CHANGES = 1, and the zero-value balance rule. Storage classification is an elevated matrix: whether the slot is read, whether the written value equals the original, zero vs non-zero, reverted vs committed frames, and multiple transactions touching the same slot all interact to decide between storage_changes, storage_reads and absence. Level 3.

Human An elevated number of cases is required. Per `test_cases.md` the BAL implementation drove gas off-by-one boundary tests at every state-access opcode (cold vs warm × OOG-before-target-access / OOG-after-target-access / success-minus-1 / success). Add: net-zero storage filtering (intra-tx coalescing, cross-frame shadowing, nested DELEGATECALL net-zero), CREATE/CREATE2 collisions, same-tx create+SELFDESTRUCT, 7702 invalid-nonce/invalid-chain-id, static-context filtering across all call opcodes, empty-block coinbase, zero-tip coinbase, system-address surplus filtering, RIPEMD-160 cross-block state leak, lexicographic byte-ordering endian traps.

Cryptography000Agree
Show rationale

LLM Only a commitment to a new structure is added, presumably with an existing hash primitive. Changed hashed bytes belong under encoding, so level 0.

Human Keccak-256 over RLP only — already covered.

State-access ordering within opcode execution3n/a—Only in revision 3
Show rationale

LLM The rubric counts which accesses enter the block-level access list. This EIP creates a block-wide definition of a recordable access that applies to every state-accessing opcode class: SLOAD/SSTORE, BALANCE/EXT*, CALL-family, CREATE/CREATE2 and SELFDESTRUCT. Each needs cases for cold/warm, reverted vs successful frames, out-of-gas before or after access, and static vs non-static calls. That is a definition change across operations, so level 3.

Human No rationale recorded.

State gas accounting changes0n/a—Only in revision 3
Show rationale

LLM No state-gas accounting changes, so level 0.

Human No rationale recorded.

Engine API encoding changesn/a0—Only in revision 1
Show rationale

LLM No rationale recorded.

Human Still RLP — no new wire encoding format introduced at the Engine API layer beyond what is captured under "Encoding changes (RLP/SSZ)".

New invariant on pre-existing tests2n/a—Only in revision 3
Show rationale

LLM Every baseline blockchain test in the target fork must additionally produce and check a correct BAL/bal_hash. The rubric caps a universal assertion at level 2 unless pre-fork vectors must also be re-derived, and nothing supplied shows that.

Human No rationale recorded.

New test-framework primitives3n/a—Only in revision 3
Show rationale

LLM The framework's shared block model must include an SSZ BAL body element and the bal_hash header field. That changes how every blockchain-test family builds blocks, and invalid-BAL modifiers and BAL expectation abstractions are also needed. This is a shared representation that changes construction across families, so level 3.

Human No rationale recorded.

Unspecified behavior requiring cross-client consensus3n/a—Only in revision 3
Show rationale

LLM Which addresses and slots were accessed — including reverted frames, out-of-gas paths and pre-warmed sets — was previously unobservable and now becomes consensus-visible. The supplied rules give competing interpretations and outright contradictions (system/withdrawal transaction index, duplicate recording, hash function), so agreement on shared rules and re-baselining across opcode, system-call and withdrawal families are needed. Level 3.

Human No rationale recorded.

Criterion legend and glossary

Every stacked bar, comparison matrix, and criterion table on this site uses the same criterion colours, abbreviations, and order. Colour marks the criterion group; the abbreviation and name identify the criterion. Scores are 0–3 per criterion (4 is exceptional; cross-EIP interactions is uncapped).

EVM surface

Opcodes, precompiles, and system contracts that are added or modified.

  • Added opcodes
    Introduces new opcodes
    Score anchors
    0
    No new opcodes are introduced.
    1
    A new simple opcode is introduced (no data portion, no complex stack mechanics, and a constant gas cost).
    2
    Multiple new simple opcodes are introduced, or a single new complex opcode is introduced (has data portion, or complex stack mechanics, or a dynamic gas cost).
    3
    Multiple new opcodes are introduced, and at least one of them is complex (has data portion, or complex stack mechanics, or a dynamic gas cost).
    • Cryptography opcodes are not considered complex by default. Refer to the "Cryptography" section for a separate assessment.
  • Modified opcodes
    Modifies pre-existing opcodes
    Score anchors
    0
    No pre-existing opcode modifications are introduced.
    3
    At least one pre-existing opcode's behavior is modified (not including gas changes) or a pre-existing opcode is deprecated.
  • Added precompiles
    Introduces new precompiles
    Score anchors
    0
    No new precompiles are introduced.
    1
    A new simple precompile is introduced (constant input length, constant gas cost).
    2
    Multiple new simple precompiles are introduced, or a single new complex precompile is introduced (dynamic input length or dynamic gas cost).
    3
    Multiple new precompiles are introduced, and at least one of them is complex (dynamic input length or dynamic gas cost).
    • Cryptography precompiles are not considered complex by default. Refer to the "Cryptography" for a separate assessment.
  • Modified precompiles
    Modifies pre-existing precompiles logic or gas-accounting
    Score anchors
    0
    No pre-existing precompiles are modified.
    1
    At least one pre-existing precompile has its gas schedule modified.
    2
    Multiple pre-existing precompiles have their gas schedule modified, or a single pre-existing precompile has its behavior modified.
    3
    The behavior of multiple pre-existing precompiles, or a single complex pre-existing precompile modified.
  • Added system contracts
    Introduces new system contract, stateful or not
    Score anchors
    0
    No new system contracts are introduced.
    1
    A new system contract is introduced that is not stateful nor does it trigger a new system action (e.g. requests to the consensus layer).
    2
    Multiple new system contracts are introduced or a single new system contract that is either stateful or triggers a new system action (e.g. requests to the consensus layer).
    3
    Multiple new system contracts are introduced and at least one of them is either stateful or triggers a new system action (e.g. requests to the consensus layer).
  • Modified system contracts
    Modifies pre-existing system contracts
    Score anchors
    0
    No modifications to pre-existing system contracts are introduced, directly or indirectly.
    1
    Does not directly modify any system contract, but its behavior has minor indirect effects on one or more system contracts.
    2
    Does not directly modify any system contract, but its behavior has major indirect effects on one or more system contracts.
    3
    At least one pre-existing system contract code or state is modified, which would involve irregular state transition or a similarly complex transition methodology.

Gas and accounting

Execution, blob, and state gas rules, refunds, and where charges happen inside opcodes.

  • EVM Gas rule changes
    New EVM gas accounting rules
    Score anchors
    0
    No gas accounting changes.
    1
    Existing gas accounting mechanism is updated.
    2
    A new gas accounting mechanism is introduced but it does not affect existing mechanisms nor does it affect existing tests.
    3
    A new gas accounting mechanism is introduced and affects existing mechanisms which in turn affect existing tests.
  • State-access ordering within opcode execution · not in checklist revision 1
    Changes *where inside an opcode's execution* state is accessed, or where gas is charged relative to that access. Because a state access is recorded in the block-level access list only if execution had enough gas to reach it, this ordering is consensus-critical: moving it changes the BAL at every gas boundary of every affected opcode.
    Score anchors
    0
    No change to where state is accessed, or to where gas is charged relative to a state access, within any opcode.
    1
    A single opcode's state-access or gas-charge ordering changes.
    2
    Multiple opcodes' ordering changes, or a new state-accessing operation is introduced whose position in the order must be settled.
    3
    The ordering rule changes for a whole class of state-accessing opcodes at once, or what counts as a recordable state access is redefined — requiring existing BAL vectors to be re-derived across opcodes and forks.
    • Distinct from "Modified opcodes", which asks whether an opcode's **result** changed. This row asks about the **path to the result**, which is observable even when the result is identical. An EIP can be 0 on that row and 3 on this one.
    • Score changes **to** the ordering. Do not score the fact that state accesses are observable — they always are.
    • Each boundary must be re-tested against every other dimension that can change the answer (cold/warm, static/non-static, delegated/direct, revert/success), so the case count grows multiplicatively rather than additively. Note this explicitly under Special Considerations.
  • Blob gas accounting changes
    New Blob gas accounting rules which potentially affect pre-existing tests
    Score anchors
    0
    No blob gas accounting changes.
    1
    Existing blob gas accounting mechanism is updated.
    2
    A new blob gas accounting mechanism is introduced but it does not affect existing mechanisms nor does it affect existing tests.
    3
    A new blob gas accounting mechanism is introduced and affects existing mechanisms which in turn affect existing tests.
  • State gas accounting changes · not in checklist revision 1
    New state gas accounting rules. State gas is the cost of *writing* state, as opposed to accessing or executing it: `StateGasCosts`, `COST_PER_STATE_BYTE`, the block-level state gas budget, and the spill path into execution gas.
    Score anchors
    0
    No state gas accounting changes.
    1
    An existing state gas cost or `STATE_BYTES_PER_*` rate is adjusted.
    2
    A new state-gas-charging site is introduced, or the block-level state gas budget or reservoir allocation is modified.
    3
    A new state gas charging mechanism is introduced, or the spill interaction between state gas and execution gas is modified, affecting existing gas tests.
    • Harder to test than blob gas: the spill path means state gas cannot be metered independently of execution gas, and some costs (e.g. `NEW_ACCOUNT`) are state-dependent.
  • New EVM gas refund
    New gas-refund mechanism
    Score anchors
    0
    No new gas-refund mechanisms are introduced.
    1
    A new simple gas-refund mechanism is introduced that does not affect either existing tests or existing gas-refund mechanisms.
    2
    A new complex gas-refund mechanism is introduced or a simple mechanism that affects existing tests or existing gas-refund mechanisms.
    3
    A new complex gas-refund mechanism is introduced that affects existing tests or existing gas-refund mechanisms.

Blocks, transactions, and encoding

Transaction types and validity, block and header fields, encodings, syncing, and activation-time changes.

  • New transaction types
    Introduces a new transaction type
    Score anchors
    0
    No new transaction types are introduced.
    3
    A new transaction type is introduced.
  • New or modified transaction validity mechanisms
    Creates new or modifies pre-existing transaction types' validation mechanisms
    Score anchors
    0
    No changes are introduced to the validity rules of existing transaction types or to their intrinsic gas cost calculation.
    1
    Minor adjustments are introduced to validity rules or intrinsic gas cost calculation, but they do not significantly affect existing tests.
    2
    Changes to validity rules or intrinsic gas cost calculation affect existing tests, but require only limited updates to test cases and no redesign of the testing infrastructure.
    3
    Changes to validity rules or intrinsic gas cost calculation require extensive rework or redesign of the tests or testing infrastructure.
  • New block / header fields
    Introduces new block or block header fields
    Score anchors
    0
    No new block or header fields are introduced.
    3
    A new block or header field is introduced.
  • Encoding changes (RLP/SSZ)
    Introduces encoding changes at the transaction/block/interfaces level
    Score anchors
    0
    No encoding changes are introduced at the transaction, block, or interfaces levels.
    3
    An encoding change is introduced at transaction, block or interfaces level (e.g. RLP -> SSZ).
    • "Interfaces level" includes the Engine API. Score an Engine API encoding change (e.g. JSON -> SSZ) here.
  • Block syncing changes
    Modifies block RLP validation mechanisms that require test client syncing.
    Score anchors
    0
    No new RLP validation mechanism is introduced.
    1
    A single simple RLP validation mechanism is introduced.
    2
    Multiple simple RLP validation mechanisms are introduced or a single complex one.
    3
    Multiple RLP validation mechanisms are introduced and at least one of them is deemed complex.
  • New fork activation mechanism
    Modifies state, internal variables, or similar, at the fork activation block
    Score anchors
    0
    No state modifications, internal variables or similar are modified at the fork activation block.
    3
    Either a state modification or internal variables are modified at the fork activation block.
    • Initialization of new internal variable is not considered a modification.

Client interfaces

Engine API and transition-tool interface changes.

  • Engine API changes
    Introduces new fields to the Engine API directives
    Score anchors
    0
    No new fields or communication mechanisms are introduced to the Engine API.
    1
    A single new field is introduced in one of the Engine API endpoints.
    2
    Multiple fields are introduced to one or multiple Engine API end points, or a new Engine API end-point is introduced.
    3
    Multiple fields are introduced to one or multiple Engine API end points and a new Engine API end-point is introduced.
  • Engine API encoding changes · Checklist revision 1 only
    Engine API encoding changes (the revision-1 template defines no anchor text for this row).
  • Transition-tool interface changes
    Modifies or adds new fields to the transition tool interface.
    Score anchors
    0
    No modifications to the transition tool interface are required.
    1
    A single new field needs to be introduced to the transition tool interface.
    2
    Multiple new fields or a new mechanism has to be introduced to the transition tool interface.
    3
    Multiple new fields and a new mechanism has to be introduced to the transition tool interface.
    • Special consideration must be paid to this section if the EIP introduces a mechanism that requires the state transition tool to be aware whether the block it is processing is the fork-activation block.

Testing impact

Rework, new invariants, and new primitives required in the test framework.

  • Patterns affecting pre-existing tests
    Implements a new validation mechanism or rule that translates in reworking pre-existing tests
    Score anchors
    0
    No pre-existing tests are affected by this change.
    1
    Minor subset of existing tests are affected by this change.
    2
    Considerable subset of existing tests are affected by this change but involves only a contrived category of tests.
    3
    Major subset of existing tests are affected, including diverse category of tests (benchmarks, static, multiple forks, etc.).
  • New invariant on pre-existing tests · not in checklist revision 1
    Tests that are **not about this EIP** must nonetheless assert something this EIP produces. Their logic does not change; they gain a new thing to check.
    Score anchors
    0
    Pre-existing tests assert nothing new.
    1
    A narrow, contrived category of pre-existing tests gains a new assertion.
    2
    A broad category gains a new assertion, applied mechanically.
    3
    Every test in the fork gains the assertion regardless of what it tests, and pre-fork vectors must be re-derived to satisfy it.
    • Paired with the row above, and easy to confuse with it. "Patterns affecting pre-existing tests" asks whether existing tests must be **reworked**; this row asks whether they must **additionally assert something new**. Score both — an EIP can be low on one and high on the other.
  • New test-framework primitives · not in checklist revision 1
    Requires new abstractions in the test framework itself — expectation types, modifiers, helpers — beyond writing test functions with what already exists.
    Score anchors
    0
    Existing test primitives suffice.
    1
    Existing primitives need minor extension.
    2
    New expectation or modifier primitives are required, reusable within this EIP's own test suite.
    3
    New framework-level primitives are required that become a permanent part of the framework and are used by other EIPs' tests.

Risk and validation

Security, performance, boundary conditions, and cryptography that need validation.

  • Security risks
    Introduces or modifies mechanisms that could compromise the security of the chain, users, validators, or other stakeholders, if not implemented properly.
    Score anchors
    0
    No new mechanisms are introduced that could pose a security risk.
    1
    The introduced mechanisms are self-contained, can be validated in isolation, and do not alter existing invariants that could pose a security risk for any stakeholders.
    2
    The introduced mechanisms interact with a limited number of existing components, slightly altering their security assumptions and requiring a targeted security review or fuzzing.
    3
    The introduced mechanisms interact with multiple existing components, including critical ones, substantially altering their security assumptions and requiring an extensive security review and fuzzing.
  • Performance risks
    Introduces or modifies mechanisms and requires performance validation.
    Score anchors
    0
    No new mechanisms are introduced that require performance validation.
    1
    The introduced mechanisms can be benchmarked in isolation and do not affect existing performance behavior.
    2
    The introduced mechanisms cannot be fully benchmarked in isolation, but they only have a limited impact on the existing performance benchmarks.
    3
    The introduced mechanisms cannot be benchmarked in isolation and have a substantial impact on existing performance benchmarks or have complex interactions with existing mechanisms.
  • Edge/boundary conditions
    Feature contains edge/boundary conditions.
    Score anchors
    0
    No discernible edge cases or boundary conditions are introduced.
    1
    A single edge-case or boundary-condition prone mechanism is introduced.
    2
    Multiple edge-case or boundary-condition prone mechanisms are introduced, but none of them requires an elevated number of cases to test.
    3
    Multiple edge-case or boundary-condition prone mechanisms are introduced and at least one of them requires an elevated number of cases to test.
  • Cryptography
    Introduces new cryptography mechanisms or modifies existing functionality that involves cryptography
    Score anchors
    0
    No cryptography mechanisms are introduced.
    1
    A new cryptography mechanism is introduced but it is a well known mechanism that is known to have vast resources to aid on its testing.
    2
    Multiple new cryptography mechanisms are introduced that are well-known or a single but novel mechanism is introduced that is either untested or has limited resources.
    3
    Multiple new cryptography mechanisms are introduced and at least one of them is a novel mechanism.

Coordination

Cross-EIP interactions and behavior that clients must agree on before tests exist.

  • Cross-EIP interactions
    Introduces or modifies mechanisms that affect other EIPs in either the same or past forks.
    Score anchors
    0
    Fully self-contained EIP that does not depend on, modify, or conflict with any other EIP.
    1
    The EIP interacts with one or more other EIPs in a non-critical and limited way but can be tested independently for the most part.
    2
    The EIP depends on or modifies one or more other EIPs such that coordinated testing and consideration is required, but interactions are limited in scope and not complex.
    3
    The EIP has strong interdependencies with multiple EIPs, requiring extensive coordinated cross-EIP testing as well as potential re-design of existing test vectors.
    • +1 for every 3 additional interacting EIPs beyond the first 3, each of which requires its own coordinated test cases. List the EIPs in the rationale.
    • This row is intentionally uncapped, unlike every other anchor: each interacting EIP is another axis of the test matrix, so a ceiling would make a 12-EIP product indistinguishable from a 3-EIP one.
  • Unspecified behavior requiring cross-client consensus · not in checklist revision 1
    The EIP text does not determine the answer for cases a test can construct. Clients must agree on a previously unspecified detail before tests can be baselined. The cost here is coordination and re-baselining, not test writing.
    Score anchors
    0
    The EIP text determines the answer for every case a test could construct.
    1
    A few details are unspecified but have an obvious intended reading.
    2
    Details require client agreement before tests can be written, but they are localized.
    3
    A previously unspecified *and previously unobservable* behavior becomes consensus-critical; expect tests to be re-baselined on each round of EIP amendment.
    • Score this from the EIP's state at assessment time: whether it has client implementations, whether it has been through a devnet, and how many open questions remain on its discussion thread.