Repository navigation
Test Cases Tracker for EIP-8141: Frame Transaction #3358
Unanswered
gurukamath
asked this question in
Ideas
Replies: 4 comments 2 replies
1 reply
|
Added to the test cases tracker |
1 reply
|
Added to the PP and updated the test tracker |
|
Storage-refund settlement / EIP-7778 interaction: verify that an EIP-8141 frame transaction storage refund reduces payer-facing cumulative gas while block execution-gas accounting remains pre-refund. Regression and implementation fix: #3443 |
0 replies
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Uh oh!
There was an error while loading. Please reload this page.
Uh oh!
There was an error while loading. Please reload this page.
test_transfer_with_default_codeVERIFYframe approving execution and payment against the sender's signature entry, followed by aSENDERframe carrying10**17wei to a recipient EOAtest_contract_sender_approvesAPPROVEAPPROVE(0, 0, EXECUTION_AND_PAYMENT); aSENDERframe calls a target contract that writes storagetest_eoa_paymasterVERIFYframe approves execution only; a secondVERIFYframe targets the payer EOA and approves payment only, backed by the payer's signature entry; aSENDERframe calls the targettest_atomic_batch_rollbackLOG0frame and a reverting frame form an atomic batch after theVERIFYframe; theATOMIC_BATCH_FLAGplacement selects which frame terminates the batch:•
unrolls_executed_frames: the storage frame is flagged, so the reverting frame terminates the batch•
skips_remaining_frames: the reverting frame is flagged and runs first•
unrolls_executed_frames: the executed batch frame's state changes are unrolled; its receipt retains statusSUCCESSand gas used but logs are discarded•
skips_remaining_frames: the remaining batch frame is skipped with status0x2(SKIPPED) andgas_used=0test_sender_frame_before_approvalSENDERframe that runs before any frame has approved executionSENDERframe calling a target precedes theVERIFYframe that would approve executionTYPE_6_INVALID_FRAME_EXECUTION; target storage untouchedtest_verify_frame_revertsVERIFYframe revertsVERIFYframe withAPPROVE_NONEtargets a contract that executesREVERT(0, 0)TYPE_6_INVALID_FRAME_EXECUTIONtest_frame_revert_discards_the_approval_it_grantedAPPROVEexits its own call context, so the frame's targetCALLs back into itself: the nested call approves execution and payment and returns, then the outer frame (parametrized)revertsorreturnsreturns(control): accepted with the payer bound, pinning that the nested approval was granted•
reverts: the approval context rolls back with the frame's state — nonce increment andmax_costescrow included — leaving no payer, so the transaction is rejected withTYPE_6_INVALID_FRAME_EXECUTION. Keeping it would produce a free transaction: fees settling against an account whose escrow was rolled backtest_refused_approval_reverts_only_its_call_frameAPPROVE, not the whole frameCALLs itself; the inner invocation attempts a scope outside the frame's own and is refused. Parametrized inner code:•
refused_approval: theAPPROVE•
plain_return(control): a bareSTOPFAILUREreceipt.•
refused_approval: the recorded outcome is 0 and the frame still succeeds•
plain_return: the outcome is 1, attributing the 0 to the refusal rather than to the nested call itselftest_expiry_verifier_frameVERIFYframe withAPPROVE_NONEtargets the expiry verifier predeploy carrying an 8-byte big-endian expiry timestamp; aSENDERframe follows. The predeploy's genesis account is pinned in the post state so a missing predeploy fails loudly. Parametrized expiry:•
future_expiry: block timestamp + 1•
expiry_at_block_timestamp: exactly the block timestamp•
expired: block timestamp − 1future_expiry/expiry_at_block_timestamp: all frames succeed and the target executes•
expired: the predeploy reverts, which for aVERIFYframe invalidates the whole transaction withTYPE_6_INVALID_FRAME_EXECUTIONtest_txparamTXPARAMDEFAULTframe storesTXPARAM(selector), one selector per case:•
type•
nonce•
priority_fee•
max_fee•
max_blob_fee•
blob_count•
frame_count•
frame_index•
signature_count•
type: the frame transaction type•
nonce: 0•
priority_fee/max_fee: the transaction's fee fields•
max_blob_fee/blob_count: 0 (no blobs)•
frame_count: 2•
frame_index: 1•
signature_count: 1test_txparam_max_costTXPARAM's max cost selector against the payer's escrowTXPARAM(MAX_COST)with the gap between the sender's funding and itsBALANCEduring frame executiontest_txparam_sender_and_sig_hashTXPARAMTXPARAM(SENDER),ISZERO(TXPARAM(SIG_HASH)), andSIGPARAM(1, MSG)of an explicit-digest signature entrymsgreads back as the exact digesttest_txparam_state_gas_leftTXPARAMtest_frameparamFRAMEPARAMFRAMEPARAM(frame_index, selector), one selector per case:• against frame 0 (
VERIFY):mode,flags,allowed_scope,empty_data(data length 0),gas_limit,state_gas_limit,atomic_batch,status_of_earlier_frame• against frame 1 (the probe's own):
data_length,value,own_gas_limitSUCCESSstatus and the probe frame's own gas limit and data length. Declared budgets are static data, so a frame may read its ownstate_gas_limittest_frameparam_resolved_targetFRAMEPARAMreports the resolved targetFRAMEPARAM(TARGET)of frame 0 (empty target) and frame 1 (the probe itself)test_frameparam_atomic_batch_setFRAMEPARAMATOMIC_BATCH_FLAG; a trailingDEFAULTframe terminates the batch (a flagged frame cannot be last). Probe reads both the dedicatedATOMIC_BATCHselector and the rawFLAGSATOMIC_BATCH_FLAGtest_frameparam_gas_usedFRAMEPARAMEXECUTION_GAS_USEDandSTATE_GAS_USEDtest_frameparam_haltsFRAMEPARAMhalts exceptionally on invalid reads•
status_of_current_frame/execution_gas_used_of_current_frame/state_gas_used_of_current_frame: the receipt-reported selectors of frame 1, read from frame 1 itself•
frame_index_out_of_bounds: frame index 2 in a two-frame transaction•
undefined_param: selector0x0CVERIFYmodetest_introspection_haltsTXPARAM,SIGPARAM,SIGDATACOPY,FRAMEDATALOADandFRAMEDATACOPYhalt exceptionally on undefined selectors, out of bounds indices, and withheld metadata•
txparam_undefined_param•
sigparam_undefined_copy_param: selector0x04, the former copy selector removed when the copy moved toSIGDATACOPY•
sigparam_undefined_param•
sigparam_length_of_protocol_validated_entry:SIGNATURE_LENGTHof the secp256k1 entry — raw bytes of protocol-validated schemes, length included, are not introspectable•
sigparam_signature_index_out_of_bounds•
sigdatacopy_signature_index_out_of_bounds•
framedataload_frame_index_out_of_bounds•
framedatacopy_frame_index_out_of_boundstest_framedataloadFRAMEDATALOAD•
first_word: offset 0 of the probe frame•
tail_zero_padded: offset 32, straddling the end of the 40-byte data•
past_the_end: offset 64•
empty_frame_data: offset 0 of frame 0, which carries no datafirst_word: reads back exactly•
tail_zero_padded: the 8-byte tail reads back left-aligned and zero-padded•
past_the_end/empty_frame_data: read as zerotest_framedatacopyFRAMEDATACOPYMLOADtest_sigparamSIGPARAMARBITRARYentry with a 5-byte witness. Parametrized reads:•
secp256k1_scheme:SCHEMEof entry 0•
canonical_hash_msg:MSGof entry 0•
arbitrary_scheme:SCHEMEof entry 1•
arbitrary_length:SIGNATURE_LENGTHof entry 1SECP256K1,msgreads zero (canonical-hash entry)•
ARBITRARYentry: its scheme and the witness length 5SIGNATURE_LENGTHof a protocol-validated entry halts instead (seetest_introspection_halts)06035145)test_sigparam_resolved_signerSIGPARAMSIGPARAM(RESOLVED_SIGNER)of the secp256k1 entry; a second probe attempts the same read against anARBITRARYentry, writing a marker firstARBITRARYentry halts the frame (protocol assigns no signer to bytes it does not validate), rolling back the markertest_sigdatacopyARBITRARYentry's raw signature bytes into memory throughSIGDATACOPYARBITRARYwitness through a 32-byte window and stores it; a second attempts the same copy against the protocol-validated secp256k1 entry, writing a marker firsttest_sigparam_copy_arbitrary: EIP rev06035145moved the copy from aSIGPARAMselector to the dedicatedSIGDATACOPYopcode, with the signature index at the bottom of the stacktest_sender_is_warmDEFAULTframe runs a gas probe measuringBALANCE(sender); the frame involves the sender in no other waygas_usedpins the cold entry charge for the probe contract itself plus the probe codetest_coinbase_is_warmDEFAULTframe runs a gas probe measuringBALANCE(coinbase)test_frame_target_entry_chargeDEFAULTframes share the same non-pre-warmed target; the target's code ends with the parametrized outcome:•
success_carries_target_warmth: targetSTOPs•
revert_discards_target_warmth: targetREVERTs•
halt_discards_target_warmth: target halts onINVALID, gated on call data (first frame sends none and halts, second sends one byte and executes cleanly) so the receipts stay observable•
success: second frame pays only the warm access•
revert: warmth discarded, second frame pays cold again•
halt: frame forfeits its entire gas limit and discards the target's warmth, so the second frame pins a cold entry chargetest_warmth_carry_to_next_frameBALANCE(subject)then ends with the parametrized outcome; the next frame's probe measuresBALANCE(subject):•
success_carries: warmerSTOPs•
revert_discards: warmerREVERTs•
halt_discards: warmer halts onINVALIDsuccess: the frame commits its accesses to the warm journal shared across frames, next frame measures warm•
revert/halt: accesses discarded, next frame pays cold (the halting frame additionally forfeits its whole gas limit)test_warmth_from_inner_callCALLs a child that executesBALANCE(subject)and ends withchild_outcome; the outer contract then ends withframe_outcome; the next frame probesBALANCE(subject). Parametrized(child_outcome, frame_outcome):•
child_and_frame_succeed: (success, success)•
child_reverts: (revert, success)•
child_halts: (halt, success)•
frame_reverts: (success, revert)•
frame_halts: (success, halt)test_payer_warm_after_default_code_payment_approvalBALANCE(payer)test_origin_warmth_by_frame_modeORIGIN's warm or cold access cost in each frame modeBALANCE(ORIGIN), pinned through the frame receipt's gas — no state writes, so the probe runs unchanged inVERIFYDEFAULT/VERIFY:ORIGINis the entry point, which is not pre-warmed — the access is cold.SENDER:ORIGINis the transaction sender, which seeds the warm journal — warmtest_same_frame_refilltest_cross_frame_refillFRAMEPARAMbefore and aftertest_refill_after_intermediate_modificationtest_state_gas_exhaustionexact_budget) or one below (one_below)exact_budget: the frame succeeds consuming the whole pool•
one_below: the frame halts exceptionally — the write rolls back, the receipt reports the whole execution budget and zero state gas — and the transaction stays validtest_approve_creates_sendertest_approve_sender_creation_unaffordableVERIFYframe declares no state gasAPPROVEinside the default code halts the frame exceptionally with no approval effects; the failingVERIFYframe invalidates the transaction withTYPE_6_INVALID_FRAME_EXECUTIONtest_batch_unroll_restores_refilled_receipttest_frame_revert_restores_refilled_receipttest_calldata_floor_with_state_gastest_storage_refund_settlementDEFAULTframe clears a slot that existed before the transaction and declares no state gas, since clearing durable state consumes none; the worker pads its execution with 400 warm balance reads so the refund cap — a fifth of pre-refund usage — stays above the clearing refund and it applies in full. Frame data is grown until the calldata floor lands in the parametrized position:•
post_refund_above_floor: floor below post-refund usage•
floor_between_pre_and_post_refund: floor between the two•
floor_above_pre_refund: floor above pre-refund usagemax(post-refund execution, floor)plus final attributed state gas, while the block's execution counter ismax(pre-refund execution, floor)— EIP-7778 counts block execution gas before storage refunds, so the refund lowers the payer's charge without lowering the block's. Frame receipts report pre-refund execution throughout; the refund applies only at settlement. Pinned through the receipt'scumulative_gas_usedand the block header'sgas_usedtest_batch_unroll_refill_restores_spent_gastest_batch_unroll_restores_refilled_receipt, which pins the receipt edit itselfFRAMEPARAMtest_frame_revert_refill_restores_spent_gastest_frame_revert_restores_refilled_receipttest_value_transferSENDERframe carries value, parametrized: to another account, to the sender explicitly, or to the sender through the empty targettest_value_transfer_exceeding_balanceSENDERframe moves one wei moregas_usedequal to its target's entry access — the balance check runs after that charge, not before it — with no state gas, no transfer log, and the recipient untouched; aSENDERframe's failure leaves the transaction validtest_invalid_tx_fieldsVERIFYframe, default code) with one field overridden per case:•
nonce_overflow: nonce2**64 − 1, leaving no room for the post-execution increment•
priority_fee_above_max_fee: priority fee 11, max fee 10•
priority_fee_equals_max_fee: both 10 (boundary, valid)•
max_fee_overflow: max fee2**256, one above the 256-bit bound•
priority_fee_overflow: priority fee2**256•
no_frames: empty frame list•
frame_count_above_max:MAX_FRAMES + 1frames•
frame_count_at_max: exactlyMAX_FRAMESframes (boundary, valid)•
blob_fee_without_blobs:max_fee_per_blob_gasset with an empty blob hash list•
invalid_blob_hash_version: blob hash with version byte 2•
blob_count_above_max:max_blobs_per_tx() + 1blob hashes•
nonce_overflow:NONCE_IS_MAX•
priority_fee_above_max_fee:PRIORITY_GREATER_THAN_MAX_FEE_PER_GAS•
max_fee_overflow:GASPRICE_OVERFLOW•
priority_fee_overflow:PRIORITY_OVERFLOW(the overflow check precedes the priority-above-max comparison)•
no_frames/frame_count_above_max/blob_fee_without_blobs:TYPE_6_INVALID_FRAME_FORMAT•
invalid_blob_hash_version:TYPE_3_TX_INVALID_BLOB_VERSIONED_HASH•
blob_count_above_max:TYPE_3_TX_BLOB_COUNT_EXCEEDEDThe boundary variants are accepted. Sender nonce increments only on acceptance
test_invalid_tx_fields_transactiontest_invalid_tx_fieldsat the transaction levelTX_FIELD_CASES); each case fills as a transaction fixture asserting accept or reject on the transaction itselftest_frame_constraints•
default_frame_with_value: value on aDEFAULTframe•
verify_frame_with_value: value on aVERIFYframe•
sender_frame_with_value: value on aSENDERframe (valid — the empty target resolves to the sender, transferring to itself)•
approve_execution_frame_with_foreign_target: execution-approvingVERIFYframe targeting a foreign address•
approve_execution_frame_with_explicit_sender_target: same but explicitly targeting the sender (valid)•
atomic_flag_on_verify_frame•
atomic_flag_on_last_frame•
atomic_batch_followed_by_verify_frame•
atomic_batch_of_default_frames: batch with a trailingDEFAULTterminator (valid)•
frame_gas_sum_overflows: each frame's execution gas limit fits 64 bits but their total does not•
frame_state_gas_sum_overflows: the state budgets alone overflow the 64-bit total•
frame_gas_cross_dimension_sum_overflows:2**63execution plus2**63state, overflowing only across dimensionsDecode-time rejections (out-of-domain values never construct, so the transaction never decodes):
•
undefined_frame_mode/undefined_frame_mode_high: mode 3 / 255•
reserved_frame_flag/reserved_frame_flag_high: flags 0x08 / 0xFF•
frame_gas_above_64_bits: frame execution gas limit2**64•
frame_state_gas_above_64_bits: frame state gas limit2**64TYPE_6_INVALID_FRAME_FORMAT; the nearest-valid variants (sender_frame_with_value,approve_execution_frame_with_explicit_sender_target,atomic_batch_of_default_frames) acceptedtest_frame_constraints_transactiontest_frame_constraintsat the transaction levelFRAME_CASESwith the state testtest_invalid_tx_fields_transaction)test_expiry_verifier_constraintsVERIFYframe targeting the expiry verifier predeploy•
expiry_data_empty/expiry_data_too_short/expiry_data_too_long: data of 0 / 7 / 9 bytes•
expiry_frame_with_flags: carriesAPPROVE_PAYMENT•
expiry_frame_with_value: carries value•
expiry_frame_with_state_gas: declares a nonzero state gas budget•
multiple_expiry_frames: two well-formed expiry frames in one transaction•
default_frame_targeting_expiry_verifier:DEFAULTframe targeting the predeploy with 7-byte data (valid — shape rules apply only toVERIFYframes, and a failing non-VERIFYframe does not invalidate the transaction)•
verify_frame_with_expiry_data_to_other_target:VERIFYframe with 7-byte data targeting a succeeding contract (valid — shape rules key on the predeploy's address)TYPE_6_INVALID_FRAME_FORMAT; the two off-target variants acceptedtest_expiry_verifier_constraints_transactiontest_expiry_verifier_constraintsat the transaction levelEXPIRY_VERIFIER_CASESwith the state testtest_invalid_tx_fields_transaction)test_signature_constraintssecp256k1 (a valid signature over an explicit digest, tampered in one component):
•
secp256k1_digest_entry: untampered (valid)• signature resized to 64 / 66 / 0 bytes
•
v= 2 / 27 (the legacy transaction encoding)•
r= 0 / at the curve order•
s= 0 / high-scomplement•
secp256k1_signer_mismatch: valid signature, explicit signer differs from what it recovers to•
secp256k1_wrong_key: empty signer (resolves to the sender) but signed with an unrelated key• signer of 19 / 21 bytes
Message shape (via
ARBITRARYentries, checked before scheme dispatch):•
msgof 1 / 31 / 33 bytes•
msg_all_zeros: reserved as the EVM-visible representation of the canonical-hash caseARBITRARY:
•
arbitrary_entry: bare 5-byte witness (valid)•
arbitrary_with_signer: carries a signerP256:
•
p256_valid_entry(valid)• signature of 127 / 129 bytes
•
r= 0 / at the curve order•
s= 0 / high-s•
p256_signer_mismatch: empty signer never matches the hash of the key words•
p256_not_on_curve: signer matches a (0, 0) key that is not on the curve•
p256_signature_over_different_digest: well-formed signature over a different digest than the entry'smsgDecode-time:
• undefined signature schemes 3 / 255
TYPE_6_INVALID_FRAME_FORMAT, cryptographic ones withTYPE_6_INVALID_SIGNATURE; the three valid entries acceptedtest_signature_constraints_transactiontest_signature_constraintsat the transaction levelSIGNATURE_CASESwith the state testtest_invalid_tx_fields_transaction)test_gas_limit_cap_from_frame_gasVERIFYframe sized so the derived gas limit lands:•
at_cap: exactly on the per-transaction gas cap•
above_cap: one above itat_capaccepted;above_caprejected withGAS_LIMIT_EXCEEDS_MAXIMUMtest_gas_limit_cap_from_frame_gas_transactiontest_gas_limit_cap_from_frame_gasat the transaction levelFRAME_GAS_CAP_CASESwith the state test, building the same boundary-sized transactiontest_invalid_tx_fields_transaction)test_gas_limit_cap_from_calldata_floorDEFAULTframe carries zero-byte data driving the calldata floor to the cap boundary while the standard gas limit stays far below it:•
below_cap: the largest data length whose floor fits under the cap•
above_cap: one more bytebelow_capaccepted;above_caprejected withGAS_LIMIT_EXCEEDS_MAXIMUMtest_gas_limit_cap_from_calldata_floor_transactiontest_gas_limit_cap_from_calldata_floorat the transaction levelCALLDATA_FLOOR_CAP_CASESwith the state test, building the same boundary-sized transactiontest_invalid_tx_fields_transaction)test_gas_limit_cap_exempts_state_gastest_gas_limit_cap_exempts_state_gas_transactiontest_gas_limit_cap_exempts_state_gasat the transaction leveltest_invalid_tx_fields_transaction)test_admission_constraints•
max_cost_overflow: max fee2**255— statically valid, but its product with any derived gas limit overflows the 256-bit maximum-cost bound•
max_cost_within_bound: max fee(2**256 − 1) // transaction_gas_limit_cap(), the largest fee cap whose product with the per-transaction gas cap still fits, so it is includable regardless of the derived gas limitmax_cost_overflow: rejected withGASLIMIT_PRICE_PRODUCT_OVERFLOW•
max_cost_within_bound: accepted; the frame approves payment, escrowing the near-maximal cost, and the sender's nonce incrementstest_nonce_at_maximum2**64 − 2, one below the overflow bound, leaving room for the post-execution increment2**64 − 1test_block_capacity_reservationsGAS_ALLOWANCE_EXCEEDED)test_raw_rlp_decode_rejectionsTransactionmodelTYPE_6_INVALID_FRAME_FORMATbefore any validation or execution runstest_bal_atomic_batch_writeSENDERframe flaggedATOMIC_BATCHwrites a storage slot; the following unflagged frame terminates the batch with the parametrized outcome:•
committed: the terminatorSTOPs•
unrolled: the terminatorREVERTsSUCCESSeven when the batch unrolls.•
committed: the slot appears as a storage change carrying the written value•
unrolled: the write is dropped from the BAL and the slot is re-filed as a bare storage read; post state shows the slot unwrittentest_bal_atomic_batch_skipped_frame_absentSKIPPEDwithgas_used=0; its target is asserted absent from the BAL (explicit exclusion), and its storage stays untouchedtest_bal_frame_revert_write_droppedSENDERframe calls a target that writes a storage slot and then executesREVERT(0, 0)FAILURE; the BAL carries no storage change for the target and lists the slot as a storage read; post state shows the slot unwrittentest_bal_sponsored_payer_and_senderVERIFYframe approves execution only; a secondVERIFYframe targets the payer EOA and approves payment, backed by the payer's signature entry; aSENDERframe writes storage in a target contract. The fee per gas is pinned to the genesis base fee so the payer's charge carries no priority tiptest_precompile_targetVERIFYframe targets, dispatching by address like a top-level callDEFAULTorSENDERframe (parametrized) targets theIDENTITYprecompile carrying parametrized input:•
no_input: empty data•
one_word: 32 bytes•
two_words: 33 bytesgas_usedpins the warm frame-entry access (precompiles seed the warm set) plusIDENTITY's input-dependent cost for the exact word counttest_precompile_target_rejecting_its_inputDEFAULTframe targetsBN254_ADDwith 128 bytes that are not a pair of curve pointsFAILUREwithgas_usedequal to its entire gas limittest_verify_frame_precompile_rejecting_its_inputVERIFYframe targets a precompile that rejects its inputBN254_ADDwith 128 bytes that are not a pair of curve points; the first frame approves execution and paymentVERIFYframe invalidates the whole transaction where aDEFAULTframe's failure would stay its own: rejected withTYPE_6_INVALID_FRAME_EXECUTION, sender nonce pinned unchangedtest_verify_frame_target_above_the_precompile_gapP256VERIFYfor theVERIFYframe that targets itVERIFYframe approving nothing targetsP256VERIFY, which sits above the address gap separating it from the rest of the precompilesgas_usedpins the warm frame-entry access plusPRECOMPILE_P256VERIFY: the exact set of active precompiles routes the frame, not an address range that stops below the gaptest_verify_frame_target_inside_the_precompile_gapVERIFYframe targeting a codeless address inside the precompile gapVERIFYframe approving nothing targets an unassigned address in the gap belowP256VERIFYTYPE_6_INVALID_FRAME_EXECUTIONand leaving the sender's nonce unchanged — an address range spanning the gap would dispatch a precompile instead and accept ittest_delegated_target_entry_chargeDEFAULTframe targets an EOA delegated to aSTOPcontract; the delegate's warmth is parametrized:•
cold_delegate: no prior access•
warm_delegate: a preceding frame targets the delegate directly, paying its cold accessframe_entry_gas_calculator(delegated=True, delegation_warm=...): the target's cold access plus the delegate's cold or warm accesstest_dead_target_entry_chargeSENDERframe moves value to a nonexistent account; the target has no code, so the frame'sgas_usedis the entry charge alone, derived fromframe_entry_gas_calculator(sends_value_to_dead_account=True). Parametrized gas limit:•
affordable: the entry charge plus ample headroom•
unaffordable: one gas below the chargeaffordable: frame succeeds, receiptgas_usedpins the entry charge exactly, the target is revived holding the value•
unaffordable: the frame never runs — it forfeits its whole gas limit (gas_used= limit, statusFAILURE), the target stays dead, and no transfer log is emitted; the transaction itself stays validtest_delegated_to_precompile_targetDEFAULTframe carrying one word of input targets an EOA delegated toIDENTITYIDENTITY's per-word cost despite the input pins that no precompile ran (the delegate, a precompile, is pre-warmed)test_verify_frame_delegated_to_precompile_targetVERIFYframe's delegated target rather than running the default codeVERIFYframe approving nothing targets an EOA delegated toIDENTITY: the resolved code is empty, as for a codeless target, but the target itself holds a designation and so is not codelesstest_frame_entry_gas_boundaryDEFAULTframe targets a codeless account, so the target's cold access fromframe_entry_gas_calculatoris the whole of the frame's execution. Parametrized gas limit:•
affordable: exactly that charge•
one_gas_short: one below itaffordable: the frame succeeds with receiptgas_usedequal to the entry charge, all of its budget spent•
one_gas_short: the frame halts exceptionally, forfeiting its whole limit (gas_used= limit); aDEFAULTframe's failure is its own, so the transaction stays valid and the sender's nonce incrementstest_default_code_entry_gas_shortfallVERIFYframe targets the payer and approves payment through the default code, with its gas limit parametrized against the payer's cold entry access:•
affordable: exactly that charge•
one_gas_short: one below itaffordable(control): the frame enters, the default code approves, and the payer is bound — attributing the other verdict to the entry charge rather than to the sponsorship shape•
one_gas_short: the frame halts before the default code is evaluated, so no approval is granted and the failedVERIFYframe invalidates the transaction withTYPE_6_INVALID_FRAME_EXECUTION, leaving the sender's nonce untouchedtest_entry_charge_halt_unrolls_batchVERIFYframe, then twoATOMIC_BATCH_FLAGframes and an unflagged terminator: the first batch frame writes a slot within an exact budget, the second targets a fresh EOA withframe_entry_gas_calculator() − 1, the most gas that still cannot afford its cold entry accessSUCCESSand its execution gas with its state gas zeroed, the halting frame forfeits its whole budget withFAILURE, and the terminator isSKIPPEDwithgas_used=0; the write is discarded and the transaction stays validtest_bal_omits_signature_validation_precompilesecrecoverandP256VERIFYare exercised, and asserts each address absent from the block access listtest_bal_unaffordable_designation_absentSENDERframe targets an EOA delegated to a storage-writing contract, with gas limitframe_entry_gas_calculator(delegated=True) − 1— the most gas that still cannot afford the designation's accesstest_expiry_verifier_installed_at_fork_transitionAmsterdamToBogotaAtTime15k. A probe recordsEXTCODESIZEof the verifier per block, keyed by block number, across a pre-fork block, the activation block and one after; a pre-fork transaction also sends to the verifier's address. Parametrized over the account's pre-fork state × whether that transaction carries value:•
absent_before_fork/balance_before_fork(nonce 0, balance 1) /nonce_and_balance_before_fork(nonce 7, balance 1)•
no_transfer/transfer_before_forkEXTCODESIZEreads 0 in the pre-fork block and the full code size from the activation block on. The post state pins nonce, balance and code, so an install writing anything besides the code fails: an untouched address ends at nonce 0 and balance 0, and an existing account keeps its nonce and its balance whether that balance came from the genesis allocation or from the pre-fork transfertest_expiry_frame_in_first_post_fork_blockAmsterdamToBogotaAtTime15k: an empty pre-fork block, then a frame transaction carryingVERIFY, expiry andSENDERframes in the activation block itselfAll reactions