Test Cases Tracker for EIP-8141: Frame Transaction

[gurukamath]

Function Name	Category	Goal	Setup	Expectation	Status
test_transfer_with_default_code	Core Flows	Transfer ETH from an EOA sender through the default verify code	VERIFY frame approving execution and payment against the sender's signature entry, followed by a SENDER frame carrying 10**17 wei to a recipient EOA	Both frames succeed, receipt payer is the sender, recipient receives the value, sender nonce increments to 1	✅ Completed (#3047)
test_contract_sender_approves	Core Flows	Send a frame transaction from a contract account that approves via APPROVE	Sender is a contract whose code executes APPROVE(0, 0, EXECUTION_AND_PAYMENT); a SENDER frame calls a target contract that writes storage	Both frames succeed, target storage written, contract sender's nonce increments 1 → 2	✅ Completed (#3047)
test_eoa_paymaster	Core Flows	Sponsor a frame transaction's fees from a second EOA via the default code	Sender's VERIFY frame approves execution only; a second VERIFY frame targets the payer EOA and approves payment only, backed by the payer's signature entry; a SENDER frame calls the target	Receipt payer is the paymaster, sender's balance is untouched, payer's nonce stays 0, target storage written	✅ Completed (#3047)
test_atomic_batch_rollback	Core Flows	Roll back an atomic batch containing a reverting frame	A storage-writing+LOG0 frame and a reverting frame form an atomic batch after the VERIFY frame; the ATOMIC_BATCH_FLAG placement 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	In both cases the storage write is discarded. • unrolls_executed_frames: the executed batch frame's state changes are unrolled; its receipt retains status SUCCESS and gas used but logs are discarded • skips_remaining_frames: the remaining batch frame is skipped with status 0x2 (SKIPPED) and gas_used=0	✅ Completed (#3047)
test_sender_frame_before_approval	Core Flows	Reject a SENDER frame that runs before any frame has approved execution	SENDER frame calling a target precedes the VERIFY frame that would approve execution	Transaction rejected with TYPE_6_INVALID_FRAME_EXECUTION; target storage untouched	✅ Completed (#3047)
test_verify_frame_reverts	Core Flows	Reject a frame transaction whose VERIFY frame reverts	Second VERIFY frame with APPROVE_NONE targets a contract that executes REVERT(0, 0)	Transaction rejected with TYPE_6_INVALID_FRAME_EXECUTION	✅ Completed (#3047)
test_expiry_verifier_frame	Expiry Verifier	Execute a frame transaction carrying an expiry verifier frame	A VERIFY frame with APPROVE_NONE targets the expiry verifier predeploy carrying an 8-byte big-endian expiry timestamp; a SENDER frame 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 − 1	• future_expiry / expiry_at_block_timestamp: all frames succeed and the target executes • expired: the predeploy reverts, which for a VERIFY frame invalidates the whole transaction with TYPE_6_INVALID_FRAME_EXECUTION	✅ Completed (#3047)
test_txparam	Introspection	Read transaction scoped information through TXPARAM	Probe contract in a DEFAULT frame stores TXPARAM(selector), one selector per case: • type • nonce • priority_fee • max_fee • max_blob_fee • blob_count • frame_count • frame_index • signature_count	Each selector reads back its pinned value: • 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: 1	✅ Completed (#3047)
test_txparam_max_cost	Introspection	Check TXPARAM's max cost selector against the payer's escrow	Probe compares TXPARAM(MAX_COST) with the gap between the sender's funding and its BALANCE during frame execution	The two values are equal: the maximum cost is charged to the payer in full when payment is approved and only refunded at settlement	✅ Completed (#3047)
test_txparam_sender_and_sig_hash	Introspection	Read the sender and the canonical signature hash through TXPARAM	Probe stores TXPARAM(SENDER), ISZERO(TXPARAM(SIG_HASH)), and SIGPARAM(1, MSG) of an explicit-digest signature entry	Sender reads back exactly; the canonical signature hash reads back nonzero (its value covers the raw signature bytes, unknowable at authoring time); the explicit-digest entry's msg reads back as the exact digest	✅ Completed (#3047)
test_frameparam	Introspection	Read frame scoped information through FRAMEPARAM	Probe stores FRAMEPARAM(frame_index, selector), one selector per case: • against frame 0 (VERIFY): mode, flags, allowed_scope, empty_data (data length 0), gas_limit, atomic_batch, status_of_earlier_frame • against frame 1 (the probe's own): data_length, value, own_gas_limit	Each selector reads back its pinned value, including the earlier frame's SUCCESS status and the probe frame's own gas limit and data length	✅ Completed (#3047)
test_frameparam_resolved_target	Introspection	FRAMEPARAM reports the resolved target	Probe reads FRAMEPARAM(TARGET) of frame 0 (empty target) and frame 1 (the probe itself)	Frame 0's empty target reads back as the transaction sender; frame 1's target reads back as the probe contract	✅ Completed (#3047)
test_frameparam_atomic_batch_set	Introspection	Read the atomic batch flag of a flagged frame through FRAMEPARAM	Probe frame carries ATOMIC_BATCH_FLAG; a trailing DEFAULT frame terminates the batch (a flagged frame cannot be last). Probe reads both the dedicated ATOMIC_BATCH selector and the raw FLAGS	The dedicated selector reads 1 and the raw flags read ATOMIC_BATCH_FLAG	✅ Completed (#3047)
test_frameparam_halts	Introspection	FRAMEPARAM halts exceptionally on invalid reads	Probe writes a marker to storage before the halting read, so a selector that returned zero instead of halting would leave the marker behind. Parametrized halting reads: • status_of_current_frame: FRAMEPARAM(1, STATUS) from frame 1 itself • frame_index_out_of_bounds: frame index 2 in a two-frame transaction • undefined_param: selector 0x09	The frame halts (marker rolled back) without invalidating the transaction, because the frame does not run in VERIFY mode	✅ Completed (#3047)
test_introspection_halts	Introspection	TXPARAM, SIGPARAM, FRAMEDATALOAD and FRAMEDATACOPY halt exceptionally on undefined selectors and out of bounds indices	Probe writes a marker before the halting read. The probe transaction carries two frames and one signature entry, so frame index 2 and signature index 1 are the first indices out of bounds. Parametrized halting reads: • txparam_undefined_param • sigparam_undefined_param • sigparam_signature_index_out_of_bounds • framedataload_frame_index_out_of_bounds • framedatacopy_frame_index_out_of_bounds	The frame halts (marker rolled back) without invalidating the transaction	✅ Completed (#3047)
test_framedataload	Introspection	Read a word of a frame's data through FRAMEDATALOAD	Probe frame carries 40 bytes of data. Parametrized reads: • 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 data	• first_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 zero	✅ Completed (#3047)
test_framedatacopy	Introspection	Copy a frame's data into memory through FRAMEDATACOPY	Probe copies two 32-byte windows of the 40-byte frame data into memory and stores both via MLOAD	The first window matches the data exactly; the second straddles the end of the data and is zero filled	✅ Completed (#3047)
test_sigparam	Introspection	Read signature scoped metadata through SIGPARAM	Two signature entries: a secp256k1 entry and an ARBITRARY entry with a 5-byte witness. Parametrized reads: • secp256k1_scheme: SCHEME of entry 0 • secp256k1_length: SIGNATURE_LENGTH of entry 0 • canonical_hash_msg: MSG of entry 0 • arbitrary_scheme: SCHEME of entry 1 • arbitrary_length: SIGNATURE_LENGTH of entry 1	• secp256k1 entry: scheme SECP256K1, length 65, msg reads zero (canonical-hash entry) • ARBITRARY entry: its scheme and the witness length 5	✅ Completed (#3047)
test_sigparam_resolved_signer	Introspection	Read the resolved signer of a protocol-validated entry through SIGPARAM	One probe reads SIGPARAM(RESOLVED_SIGNER) of the secp256k1 entry; a second probe attempts the same read against an ARBITRARY entry, writing a marker first	The validated entry's resolved signer reads back as the sender; the read against the ARBITRARY entry halts the frame (protocol assigns no signer to bytes it does not validate), rolling back the marker	✅ Completed (#3047)
test_sigparam_copy_arbitrary	Introspection	Copy an ARBITRARY entry's raw signature bytes into memory via SIGPARAM's copy operation	One probe copies the ARBITRARY witness into memory and stores it; a second attempts the same copy against the protocol-validated secp256k1 entry	The witness bytes read back zero-padded; the copy against the validated entry halts the frame	✅ Completed (#3047)
test_sender_is_warm	Warmth	The transaction sender seeds the warm journal of every frame	A DEFAULT frame runs a gas probe measuring BALANCE(sender); the frame involves the sender in no other way	The measured access is warm; the probe frame's receipt gas_used pins the cold entry charge for the probe contract itself plus the probe code	✅ Completed (#3047)
test_coinbase_is_warm	Warmth	The coinbase is warmed at the entry of every frame	A DEFAULT frame runs a gas probe measuring BALANCE(coinbase)	The measured access is warm	✅ Completed (#3047)
test_frame_target_entry_charge	Warmth	Charge a frame's target access at frame entry, within the frame's own gas	Two consecutive DEFAULT frames share the same non-pre-warmed target; the target's code ends with the parametrized outcome: • success_carries_target_warmth: target STOPs • revert_discards_target_warmth: target REVERTs • halt_discards_target_warmth: target halts on INVALID, gated on call data (first frame sends none and halts, second sends one byte and executes cleanly) so the receipts stay observable	First frame's receipt pins the cold account access plus code cost. • 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 charge	✅ Completed (#3047)
test_warmth_carry_to_next_frame	Warmth	Warm an address in one frame and measure its access cost in the next	A warmer frame executes BALANCE(subject) then ends with the parametrized outcome; the next frame's probe measures BALANCE(subject): • success_carries: warmer STOPs • revert_discards: warmer REVERTs • halt_discards: warmer halts on INVALID	• success: 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)	✅ Completed (#3047)
test_warmth_from_inner_call	Warmth	Warm an address at call depth 1 inside a frame and measure its access cost in the next frame	An outer frame contract CALLs a child that executes BALANCE(subject) and ends with child_outcome; the outer contract then ends with frame_outcome; the next frame probes BALANCE(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)	Warmth carries only when the child returns successfully and the frame itself succeeds; either side reverting or halting discards the access and the next frame pays cold. Frame receipts pin gas where deterministic (a halting child's gas is set by the 63/64 rule and is left unpinned)	✅ Completed (#3047)
test_invalid_tx_fields	Static Validity	Vary one transaction-level field of a minimal frame transaction across static validity rules and their boundaries	Minimal valid transaction (single VERIFY frame, default code) with one field overridden per case: • nonce_overflow: nonce 2**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) • no_frames: empty frame list • frame_count_above_max: MAX_FRAMES + 1 frames • frame_count_at_max: exactly MAX_FRAMES frames (boundary, valid) • blob_fee_without_blobs: max_fee_per_blob_gas set with an empty blob hash list • invalid_blob_hash_version: blob hash with version byte 2 • blob_count_above_max: max_blobs_per_tx() + 1 blob hashes	Violations rejected with the matching exception: • nonce_overflow: NONCE_IS_MAX • priority_fee_above_max_fee: PRIORITY_GREATER_THAN_MAX_FEE_PER_GAS • 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_EXCEEDED The boundary variants are accepted. Sender nonce increments only on acceptance	✅ Completed (#3047)
test_frame_constraints	Static Validity	Vary the frame list of a minimal frame transaction against per-frame static constraints	One frame-list variation per case: • default_frame_with_value: value on a DEFAULT frame • verify_frame_with_value: value on a VERIFY frame • sender_frame_with_value: value on a SENDER frame (valid — the empty target resolves to the sender, transferring to itself) • approve_execution_frame_with_foreign_target: execution-approving VERIFY frame 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 trailing DEFAULT terminator (valid) • frame_gas_sum_overflows: each frame's gas limit fits 64 bits but their total does not Decode-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 gas limit 2**64	Violations rejected with TYPE_6_INVALID_FRAME_FORMAT; the nearest-valid variants (sender_frame_with_value, approve_execution_frame_with_explicit_sender_target, atomic_batch_of_default_frames) accepted	✅ Completed (#3047)
test_expiry_verifier_constraints	Static Validity	Vary the shape of an expiry verifier frame — a VERIFY frame targeting the expiry verifier predeploy	One shape variation per case: • expiry_data_empty / expiry_data_too_short / expiry_data_too_long: data of 0 / 7 / 9 bytes • expiry_frame_with_flags: carries APPROVE_PAYMENT • expiry_frame_with_value: carries value • multiple_expiry_frames: two well-formed expiry frames in one transaction • default_frame_targeting_expiry_verifier: DEFAULT frame targeting the predeploy with 7-byte data (valid — shape rules apply only to VERIFY frames, and a failing non-VERIFY frame does not invalidate the transaction) • verify_frame_with_expiry_data_to_other_target: VERIFY frame with 7-byte data targeting a succeeding contract (valid — shape rules key on the predeploy's address)	Violations rejected with TYPE_6_INVALID_FRAME_FORMAT; the two off-target variants accepted	✅ Completed (#3047)
test_signature_constraints	Static Validity	Vary a single signature entry against the protocol's structural and cryptographic entry validation	One signature entry appended after the canonical entry consumed by the sender's default code, varied per case. secp256k1 (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-s complement • 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 ARBITRARY entries, checked before scheme dispatch): • msg of 1 / 31 / 33 bytes • msg_all_zeros: reserved as the EVM-visible representation of the canonical-hash case ARBITRARY: • arbitrary_entry: bare 5-byte witness (valid) • arbitrary_with_signer: carries a signer P256: • 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's msg Decode-time: • undefined signature schemes 3 / 255	Structural violations rejected with TYPE_6_INVALID_FRAME_FORMAT, cryptographic ones with TYPE_6_INVALID_SIGNATURE; the three valid entries accepted	✅ Completed (#3047)
test_gas_limit_cap_from_frame_gas	Static Validity	Pin the per-transaction gas cap against the derived gas limit (intrinsic cost plus frame gas)	Contract sender (no signature entries, so the intrinsic cost is exact and content-independent); a single VERIFY frame sized so the derived gas limit lands: • at_cap: exactly on the per-transaction gas cap • above_cap: one above it	at_cap accepted; above_cap rejected with GAS_LIMIT_EXCEEDS_MAXIMUM	✅ Completed (#3047)
test_gas_limit_cap_from_calldata_floor	Static Validity	Pin that the gas cap applies to the larger of the standard gas limit and the calldata floor	Contract sender; a zero-gas DEFAULT frame 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 byte	below_cap accepted; above_cap rejected with GAS_LIMIT_EXCEEDS_MAXIMUM	✅ Completed (#3047)
test_nonce_at_maximum	Static Validity	Accept the highest nonce a frame transaction may carry	Sender EOA pre-funded with nonce 2**64 − 2, one below the overflow bound, leaving room for the post-execution increment	Transaction accepted; sender nonce increments to 2**64 − 1	✅ Completed (#3047)
test_raw_rlp_decode_rejections	Static Validity	Reject byte-level malformed frame transaction encodings at decode time	Raw RLP payloads that never construct a transaction — truncated frame lists, trailing bytes after the outer list, and wrong-width integer fields — injected as raw transaction bytes instead of being built through the Transaction model	Every malformed payload is rejected with TYPE_6_INVALID_FRAME_FORMAT before any validation or execution runs	🚧 Planned
test_bal_atomic_batch_write	Block Access List	Record an atomic batch's storage write in the header-committed BAL only when the batch commits	A SENDER frame flagged ATOMIC_BATCH writes a storage slot; the following unflagged frame terminates the batch with the parametrized outcome: • committed: the terminator STOPs • unrolled: the terminator REVERTs	The sender's nonce bump is recorded in the BAL either way — no rollback undoes it — and the write frame's receipt keeps status SUCCESS even 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 unwritten	✅ Completed (#3047)
test_bal_atomic_batch_skipped_frame_absent	Block Access List	Keep a skipped atomic-batch frame's target out of the BAL entirely	The flagged first batch frame targets a reverting contract; the remaining batch frame targets a storage-writing contract and is never executed	The skipped frame's receipt reads SKIPPED with gas_used=0; its target is asserted absent from the BAL (explicit exclusion), and its storage stays untouched	✅ Completed (#3047)
test_bal_frame_revert_write_dropped	Block Access List	Drop a reverting non-batch frame's storage write from the BAL, re-filing the slot as a bare access	A SENDER frame calls a target that writes a storage slot and then executes REVERT(0, 0)	The frame's receipt reads FAILURE; the BAL carries no storage change for the target and lists the slot as a storage read; post state shows the slot unwritten	✅ Completed (#3047)
test_bal_sponsored_payer_and_sender	Block Access List	Attribute a sponsored frame transaction's fee and nonce to distinct accounts in the BAL	The sender's VERIFY frame approves execution only; a second VERIFY frame targets the payer EOA and approves payment, backed by the payer's signature entry; a SENDER frame 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 tip	The payer shows the only balance change and no nonce change; the sender shows the nonce bump and no balance change (the empty expectations are asserted, so a spurious entry fails); the target's write is recorded. The receipt pins the payer and the charged gas, derived from the frame-transaction intrinsic, frame-entry, and bytecode gas calculators rather than an observed constant	✅ Completed (#3047)
test_precompile_target	Target Resolution	Execute the precompile a non-VERIFY frame targets, dispatching by address like a top-level call	A DEFAULT or SENDER frame (parametrized) targets the IDENTITY precompile carrying parametrized input: • no_input: empty data • one_word: 32 bytes • two_words: 33 bytes	The frame succeeds and its receipt gas_used pins the warm frame-entry access (precompiles seed the warm set) plus IDENTITY's input-dependent cost for the exact word count	✅ Completed (#3047)
test_precompile_target_rejecting_its_input	Target Resolution	Fail the frame whose targeted precompile rejects its input	A DEFAULT frame targets BN254_ADD with 128 bytes that are not a pair of curve points	The rejection is an exceptional halt: the frame's receipt reads FAILURE with gas_used equal to its entire gas limit	✅ Completed (#3047)
test_verify_frame_precompile_target	Target Resolution	Reject a frame transaction whose VERIFY frame targets a precompile: the empty code hash routes to the default code instead of dispatching	The frame under test approves nothing and targets IDENTITY; the first frame approves both execution and payment, so dispatching the precompile instead of running the default code would leave the transaction valid	Transaction rejected with TYPE_6_INVALID_FRAME_EXECUTION; sender nonce pinned unchanged	✅ Completed (#3047)
test_delegated_target_entry_charge	Target Resolution	Charge the access of a frame target's designated address at frame entry, on top of the target's own access	A DEFAULT frame targets an EOA delegated to a STOP contract; the delegate's warmth is parametrized: • cold_delegate: no prior access • warm_delegate: a preceding frame targets the delegate directly, paying its cold access	The frame's receipt pins the entry charge from frame_entry_gas_calculator(delegated=True, delegation_warm=...): the target's cold access plus the delegate's cold or warm access	✅ Completed (#3047)
test_delegated_to_precompile_target	Target Resolution	Run no precompile for a frame whose target designates one: following a designation disables precompile dispatch	A DEFAULT frame carrying one word of input targets an EOA delegated to IDENTITY	The frame succeeds executing the designated address's empty code; the receipt pins entry charges only — the absence of IDENTITY's per-word cost despite the input pins that no precompile ran (the delegate, a precompile, is pre-warmed)	✅ Completed (#3047)
test_verify_frame_delegated_to_precompile_target	Target Resolution	Follow the designation of a VERIFY frame's delegated target rather than running the default code	A VERIFY frame approving nothing targets an EOA delegated to IDENTITY: the resolved code is empty, as for a codeless target, but the target itself holds a designation and so is not codeless	The frame succeeds with entry charges only, pinning that the default-code split keys on the target's own code hash — deciding on the resolved code hash instead would run the default code and reject the transaction	✅ Completed (#3047)
test_frame_entry_gas_boundary	Gas Boundaries	Pin frame-level gas enforcement on both sides of the exact affordability edge: a frame succeeds at precisely its derived cost and one unit below it forfeits everything	A non-VERIFY frame runs with its gas limit sized to the derived full frame cost — entry charges from frame_entry_gas_calculator plus the target code's cost, including the state gas an SSTORE spills into execution gas (a frame holds no reservoir) — and one below it. Parametrized (target shape × boundary side): • plain_contract: cold storage-writing target • delegated: target designating a storage-writing contract, adding the designation's access to the entry charge • precompile: IDENTITY with input, warm entry plus the input-dependent precompile cost × exact / short_by_one	• exact: the frame succeeds with receipt gas_used equal to the full derived cost, and the target's effect (storage write / precompile output) lands • short_by_one: the frame fails forfeiting its entire gas limit (gas_used = limit), leaving state untouched; the transaction itself stays valid and the sender's nonce increments	🚧 Planned
test_bal_unaffordable_designation_absent	Block Access List	Keep a frame's designated address out of the BAL when the frame's gas cannot cover the designation's access	A SENDER frame targets an EOA delegated to a storage-writing contract, with gas limit frame_entry_gas_calculator(delegated=True) − 1 — the most gas that still cannot afford the designation's access	The frame fails forfeiting its whole gas limit — a receipt indistinguishable from a failure inside the resolved code, so the BAL discriminates: the authority appears as a bare access with no changes, the designated address is asserted absent, and its storage stays untouched	✅ Completed (#3047)

[Marchhill]

@gurukamath SamWilsn#13

[gurukamath]

Added to the test cases tracker

[Marchhill]

@gurukamath SamWilsn#14