ethrex_levm/
call_frame.rs

1use crate::{
2    account::LevmAccount,
3    constants::STACK_LIMIT,
4    errors::{ExceptionalHalt, InternalError, VMError},
5    memory::Memory,
6    utils::restore_cache_state,
7    vm::VM,
8};
9use bytes::Bytes;
10use ethrex_common::types::block_access_list::BlockAccessListCheckpoint;
11use ethrex_common::{Address, H256, U256, types::Code};
12use rustc_hash::FxHashMap;
13use std::{
14    fmt,
15    hash::{Hash, Hasher},
16    hint::assert_unchecked,
17};
18
19/// [`u64`]s that make up a [`U256`]
20const U64_PER_U256: usize = U256::MAX.0.len();
21
22#[derive(Clone, PartialEq, Eq)]
23/// The EVM uses a stack-based architecture and does not use registers like some other VMs.
24///
25/// The specification says the stack is limited to 1024 items, aka. 32KiB, which is reasonable
26/// enough for allocating it all at once to make sense. Every time an item is pushed into the stack,
27/// its bounds have to be checked; by making the stack grow downwards, the underflow detection of
28/// the offset update operation can also be reused to check for stack overflow.
29///
30/// A few opcodes require pushing and/or popping multiple elements. The [`push`](Self::push) and
31/// [`pop`](Self::pop) methods support working with multiple elements instead of a single one,
32/// reducing the number of checks performed on the stack.
33pub struct Stack {
34    pub values: Box<[U256; STACK_LIMIT]>,
35    pub offset: usize,
36}
37
38impl Stack {
39    #[inline]
40    pub fn pop<const N: usize>(&mut self) -> Result<&[U256; N], ExceptionalHalt> {
41        // Compile-time check for stack underflow.
42        const {
43            assert!(N <= STACK_LIMIT);
44        }
45
46        // The following operation can never overflow as both `self.offset` and N are within
47        // STACK_LIMIT (1024).
48        let next_offset = self.offset.wrapping_add(N);
49
50        // The index cannot fail because `self.offset` is known to be valid. The `first_chunk()`
51        // method will ensure that `next_offset` is within `STACK_LIMIT`, so there's no need to
52        // check it again.
53        #[expect(unsafe_code)]
54        let values = unsafe {
55            self.values
56                .get_unchecked(self.offset..)
57                .first_chunk::<N>()
58                .ok_or(ExceptionalHalt::StackUnderflow)?
59        };
60        // Due to previous error check in first_chunk, next_offset is guaranteed to be < STACK_LIMIT
61        self.offset = next_offset;
62
63        Ok(values)
64    }
65
66    #[inline]
67    pub fn pop1(&mut self) -> Result<U256, ExceptionalHalt> {
68        let value = *self
69            .values
70            .get(self.offset)
71            .ok_or(ExceptionalHalt::StackUnderflow)?;
72        // The following operation can never overflow as both `self.offset` and N are within
73        // STACK_LIMIT (1024).
74        self.offset = self.offset.wrapping_add(1);
75
76        Ok(value)
77    }
78
79    /// Mutable reference to the top item without changing depth (one underflow check,
80    /// no `offset` write). For stack-neutral unary ops (ISZERO, NOT, CLZ), replacing
81    /// `pop1` + `push` with `*top_mut() = f(*top)` avoids the read-modify-write of the
82    /// shared `offset`, which is the per-opcode serial dependency that pins dispatch IPC.
83    #[inline]
84    pub fn top_mut(&mut self) -> Result<&mut U256, ExceptionalHalt> {
85        self.values
86            .get_mut(self.offset)
87            .ok_or(ExceptionalHalt::StackUnderflow)
88    }
89
90    /// Overwrites the top value without a bounds check.
91    ///
92    /// # Safety
93    /// The caller must have already validated that a top element exists (e.g. a
94    /// prior `top_mut()?`/`pop1()?` in the same stack-neutral opcode) and must
95    /// not have changed the stack depth since, so `self.offset` is in bounds.
96    #[expect(unsafe_code, reason = "top validated by caller; depth unchanged")]
97    #[inline]
98    pub unsafe fn set_top_unchecked(&mut self, value: U256) {
99        unsafe {
100            *self.values.get_unchecked_mut(self.offset) = value;
101        }
102    }
103
104    /// Pop the top value and return it together with a mutable reference to the new top.
105    /// For binary ops: `let (a, b) = pop1_and_top_mut()?; *b = f(a, *b)` writes the result
106    /// in place (one `offset` write instead of `pop::<2>` + `push`'s two), where `a` is the
107    /// original top and `*b` the original second operand.
108    #[inline]
109    pub fn pop1_and_top_mut(&mut self) -> Result<(U256, &mut U256), ExceptionalHalt> {
110        let a = self.pop1()?;
111        Ok((a, self.top_mut()?))
112    }
113
114    /// Push a single U256 value to the stack, faster than the generic push.
115    #[inline]
116    pub fn push(&mut self, value: U256) -> Result<(), ExceptionalHalt> {
117        // Since the stack grows downwards, when an offset underflow is detected the stack is
118        // overflowing.
119        let next_offset = self
120            .offset
121            .checked_sub(1)
122            .ok_or(ExceptionalHalt::StackOverflow)?;
123
124        // The following index cannot fail because `next_offset` has already been checked and
125        // `self.offset` is known to be within `STACK_LIMIT`.
126        // Store each limb individually so LLVM treats them as 4 independent i64 scalars.
127        // This prevents LLVM from grouping limbs[1..3] into a [24 x i8] alloca that would
128        // then need a memset + memcpy round-trip for values with known-zero upper limbs
129        // (e.g. PUSH1-PUSH31), allowing it to emit direct zero stores instead.
130        #[expect(unsafe_code, reason = "next_offset == self.offset - 1 >= 0")]
131        unsafe {
132            let slot = self.values.get_unchecked_mut(next_offset);
133            slot.0[0] = value.0[0];
134            slot.0[1] = value.0[1];
135            slot.0[2] = value.0[2];
136            slot.0[3] = value.0[3];
137        }
138        self.offset = next_offset;
139
140        Ok(())
141    }
142
143    #[inline]
144    pub fn push_zero(&mut self) -> Result<(), ExceptionalHalt> {
145        // Since the stack grows downwards, when an offset underflow is detected the stack is
146        // overflowing.
147        let next_offset = self
148            .offset
149            .checked_sub(1)
150            .ok_or(ExceptionalHalt::StackOverflow)?;
151
152        // The following index cannot fail because `next_offset` has already been checked and
153        // `self.offset` is known to be within `STACK_LIMIT`.
154        #[expect(unsafe_code, reason = "next_offset == self.offset - 1 >= 0")]
155        unsafe {
156            *self
157                .values
158                .get_unchecked_mut(next_offset)
159                .0
160                .as_mut_ptr()
161                .cast() = [0u64; U64_PER_U256];
162        }
163        self.offset = next_offset;
164
165        Ok(())
166    }
167
168    pub fn len(&self) -> usize {
169        // The following operation cannot underflow because `self.offset` is known to be less than
170        // or equal to `self.values.len()` (aka. `STACK_LIMIT`).
171        #[expect(clippy::arithmetic_side_effects)]
172        {
173            self.values.len() - self.offset
174        }
175    }
176
177    pub fn is_empty(&self) -> bool {
178        self.offset == self.values.len()
179    }
180
181    #[inline(always)]
182    pub fn swap<const N: usize>(&mut self) -> Result<(), ExceptionalHalt> {
183        // Compile-time check that ensures `self.offset + N` is safe,
184        // since self.offset is bounded by STACK_LIMIT
185        const {
186            assert!(STACK_LIMIT.checked_add(N).is_some());
187        }
188        #[expect(clippy::arithmetic_side_effects)]
189        let index = self.offset + N;
190
191        if index >= self.values.len() {
192            return Err(ExceptionalHalt::StackUnderflow);
193        }
194
195        #[expect(unsafe_code, reason = "self.offset always < STACK_LIMIT")]
196        unsafe {
197            assert_unchecked(self.offset < STACK_LIMIT)
198        };
199
200        self.values.swap(self.offset, index);
201        Ok(())
202    }
203
204    pub fn clear(&mut self) {
205        self.offset = STACK_LIMIT;
206    }
207
208    /// Pushes a copy of the value at depth N
209    #[inline]
210    pub fn dup<const N: usize>(&mut self) -> Result<(), ExceptionalHalt> {
211        // Compile-time check that ensures `self.offset + N` is safe,
212        // since self.offset is bounded by STACK_LIMIT
213        const {
214            assert!(STACK_LIMIT.checked_add(N).is_some());
215        }
216        #[expect(clippy::arithmetic_side_effects)]
217        let index = self.offset + N;
218        if index >= self.values.len() {
219            return Err(ExceptionalHalt::StackUnderflow);
220        }
221
222        self.offset = self
223            .offset
224            .checked_sub(1)
225            .ok_or(ExceptionalHalt::StackOverflow)?;
226
227        #[expect(unsafe_code, reason = "index < size, offset-1 >= 0")]
228        unsafe {
229            std::ptr::copy_nonoverlapping(
230                self.values.get_unchecked_mut(index).0.as_mut_ptr(),
231                self.values.get_unchecked_mut(self.offset).0.as_mut_ptr(),
232                U64_PER_U256,
233            );
234        }
235        Ok(())
236    }
237}
238
239impl Default for Stack {
240    fn default() -> Self {
241        Self {
242            values: Box::new([U256::zero(); STACK_LIMIT]),
243            offset: STACK_LIMIT,
244        }
245    }
246}
247
248impl fmt::Debug for Stack {
249    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
250        struct StackValues<'a>(&'a [U256]);
251
252        impl fmt::Debug for StackValues<'_> {
253            fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
254                f.debug_list().entries(self.0.iter().rev()).finish()
255            }
256        }
257
258        #[expect(clippy::indexing_slicing)]
259        f.debug_tuple("Stack")
260            .field(&StackValues(&self.values[self.offset..]))
261            .finish()
262    }
263}
264
265impl Hash for Stack {
266    #[expect(
267        clippy::indexing_slicing,
268        reason = "offset is always within bounds of values"
269    )]
270    fn hash<H: Hasher>(&self, state: &mut H) {
271        self.values[self.offset..].hash(state);
272    }
273}
274
275#[derive(Debug)]
276/// A call frame, or execution environment, is the context in which
277/// the EVM is currently executing.
278/// One context can trigger another with opcodes like CALL or CREATE.
279/// Call frames relationships can be thought of as a parent-child relation.
280pub struct CallFrame {
281    /// Max gas a callframe can use
282    pub gas_limit: u64,
283    /// Keeps track of the remaining gas in the current context.
284    ///
285    /// This is a i64 for performance reasons, to allow faster gas cost substraction and checks.
286    ///
287    /// Additionally, gas limit won't be a problem since https://eips.ethereum.org/EIPS/eip-7825 limits it to 2^24, which is lower than i64::MAX.
288    pub gas_remaining: i64,
289    /// Program Counter
290    pub pc: usize,
291    /// Address of the account that sent the message
292    pub msg_sender: Address,
293    /// Address of the recipient of the message
294    pub to: Address,
295    /// Address of the code to execute. Usually the same as `to`, but can be different
296    pub code_address: Address,
297    /// Bytecode to execute.
298    /// Its hash field will be bogus for initcodes, as it is inaccessible to the VM
299    /// unless associated to an account, which doesn't happen for its initcode.
300    pub bytecode: Code,
301    /// Value sent along the transaction
302    pub msg_value: U256,
303    pub stack: Stack,
304    pub memory: Memory,
305    /// Data sent along the transaction. Empty in CREATE transactions.
306    pub calldata: Bytes,
307    /// Return data of the CURRENT CONTEXT (see docs for more details)
308    pub output: Bytes,
309    /// Return data of the SUB-CONTEXT (see docs for more details)
310    pub sub_return_data: Bytes,
311    /// Indicates if current context is static (if it is, it can't alter state)
312    pub is_static: bool,
313    /// Call stack current depth
314    pub depth: usize,
315    /// This is set to true if the function that created this callframe is CREATE or CREATE2
316    pub is_create: bool,
317    /// Everytime we want to write an account during execution of a callframe we store the pre-write state so that we can restore if it reverts
318    pub call_frame_backup: CallFrameBackup,
319    /// Return data offset
320    pub ret_offset: usize,
321    /// Return data size
322    pub ret_size: usize,
323    /// If true then transfer value from caller to callee
324    pub should_transfer_value: bool,
325    /// EIP-8037: snapshot of VM.state_gas_used (signed) at child-frame entry.
326    /// Used to restore parent's state_gas_used on child revert.
327    pub state_gas_used_at_entry: i64,
328    /// EIP-8037: EELS per-frame `state_gas_spilled`; LIFO refund source;
329    /// propagated to parent on child success.
330    pub frame_state_gas_spilled: u64,
331    /// EIP-8037 (#3002): whether this CREATE/CREATE2 child's target address was
332    /// already alive (existed and non-empty) before the create mutated state.
333    /// Read in `handle_return_create` to refund the unconditional new-account
334    /// state gas on the success path (no new account leaf is created).
335    pub target_alive: bool,
336    /// EIP-8037: whether the parent charged new-account state gas for this CALL
337    /// (value transfer to an empty account). Refunded on child revert/error,
338    /// mirroring EELS `generic_call` `credit_state_gas_refund(NEW_ACCOUNT)`.
339    pub new_account_state_gas_charged: bool,
340}
341
342#[derive(Debug, Clone, Eq, PartialEq, Default)]
343pub struct CallFrameBackup {
344    pub original_accounts_info: FxHashMap<Address, LevmAccount>,
345    pub original_account_storage_slots: FxHashMap<Address, FxHashMap<H256, U256>>,
346    /// BAL checkpoint for EIP-7928 - used to restore state changes on revert
347    /// while preserving touched_addresses.
348    pub bal_checkpoint: Option<BlockAccessListCheckpoint>,
349    /// Code hashes this frame inserted into the by-hash code cache
350    /// (`GeneralizedDatabase::codes`) for codes it deployed. Removed from the
351    /// cache on revert: a stale entry would make a later read of the same
352    /// hash (from a pre-existing account) hit the cache instead of the store,
353    /// hiding the read from execution-witness recording (EIP-8025).
354    pub inserted_code_hashes: Vec<H256>,
355}
356
357impl CallFrameBackup {
358    pub fn backup_account_info(
359        &mut self,
360        address: Address,
361        account: &LevmAccount,
362    ) -> Result<(), InternalError> {
363        self.original_accounts_info
364            .entry(address)
365            .or_insert_with(|| LevmAccount {
366                info: account.info.clone(),
367                storage: Default::default(),
368                status: account.status.clone(),
369                has_storage: account.has_storage,
370                exists: account.exists,
371            });
372
373        Ok(())
374    }
375
376    pub fn clear(&mut self) {
377        self.original_accounts_info.clear();
378        self.original_account_storage_slots.clear();
379        self.bal_checkpoint = None;
380        self.inserted_code_hashes.clear();
381    }
382
383    /// Merges `other` into `self`, per-address. For slots present in both,
384    /// `other`'s values win. Callers MUST pass the older/more-original backup
385    /// as `other` so the truly-original value is preserved (matches the
386    /// `or_insert` semantic in `backup_storage_slot`).
387    pub fn extend(&mut self, other: CallFrameBackup) {
388        // Per-slot merge: plain HashMap::extend would let `other`'s inner slot map
389        // replace `self`'s, dropping any slots `self` had for the same address.
390        for (address, other_storage) in other.original_account_storage_slots {
391            self.original_account_storage_slots
392                .entry(address)
393                .or_default()
394                .extend(other_storage);
395        }
396        self.original_accounts_info
397            .extend(other.original_accounts_info);
398        self.inserted_code_hashes.extend(other.inserted_code_hashes);
399        // Don't extend bal_checkpoint - it's specific to each call frame
400    }
401
402    /// Absorb another backup, keeping the EARLIEST original value for each
403    /// account/slot (first-seen-wins). Mirrors `merge_call_frame_backup_with_parent`.
404    /// Does NOT touch `bal_checkpoint` (set once at the tx level).
405    ///
406    /// Unlike `extend` (last-wins `HashMap::extend`), this preserves the value
407    /// that was already recorded, which is required when accumulating per-frame
408    /// backups into a tx-level rollback: the original to restore is the value
409    /// from before the FIRST frame that modified it.
410    pub fn absorb(&mut self, other: &CallFrameBackup) {
411        for (address, account) in other.original_accounts_info.iter() {
412            self.original_accounts_info
413                .entry(*address)
414                .or_insert_with(|| account.clone());
415        }
416        for (address, storage) in other.original_account_storage_slots.iter() {
417            let slot = self
418                .original_account_storage_slots
419                .entry(*address)
420                .or_default();
421            for (key, value) in storage.iter() {
422                slot.entry(*key).or_insert(*value);
423            }
424        }
425    }
426}
427
428impl CallFrame {
429    #[expect(
430        clippy::too_many_arguments,
431        reason = "inlined constructor, many args needed for performance"
432    )]
433    // Force inline, due to lot of arguments, inlining must be forced, and it is actually beneficial
434    // because passing so much data is costly. Verified with samply.
435    #[inline(always)]
436    pub fn new(
437        msg_sender: Address,
438        to: Address,
439        code_address: Address,
440        bytecode: Code,
441        msg_value: U256,
442        calldata: Bytes,
443        is_static: bool,
444        gas_limit: u64,
445        depth: usize,
446        should_transfer_value: bool,
447        is_create: bool,
448        ret_offset: usize,
449        ret_size: usize,
450        stack: Stack,
451        memory: Memory,
452    ) -> Self {
453        // Note: Do not use ..Default::default() because it has runtime cost.
454
455        #[expect(clippy::as_conversions, reason = "remaining gas conversion")]
456        Self {
457            gas_limit,
458            gas_remaining: gas_limit as i64,
459            msg_sender,
460            to,
461            code_address,
462            bytecode,
463            msg_value,
464            calldata,
465            is_static,
466            depth,
467            should_transfer_value,
468            is_create,
469            ret_offset,
470            ret_size,
471            stack,
472            memory,
473            call_frame_backup: CallFrameBackup::default(),
474            output: Bytes::default(),
475            pc: 0,
476            sub_return_data: Bytes::default(),
477            state_gas_used_at_entry: 0,
478            frame_state_gas_spilled: 0,
479            target_alive: false,
480            new_account_state_gas_charged: false,
481        }
482    }
483
484    #[inline(always)]
485    pub fn next_opcode(&self) -> u8 {
486        // SAFETY: pc reaches at most bytecode_len + 32 (a PUSH32 at the last real
487        // byte advances 33 total: +1 in the dispatch loop, +32 in the handler).
488        // dispatch_buf() is bytecode_len + BYTECODE_PADDING (33) long, so the read
489        // is always in bounds.
490        #[expect(unsafe_code, reason = "pc bounded by padded bytecode len")]
491        unsafe {
492            *self.bytecode.dispatch_buf().get_unchecked(self.pc)
493        }
494    }
495
496    pub fn pc(&self) -> usize {
497        self.pc
498    }
499
500    /// Increases gas consumption of CallFrame and Environment, returning an error if the callframe gas limit is reached.
501    #[inline(always)]
502    #[expect(clippy::as_conversions, reason = "remaining gas conversion")]
503    #[expect(clippy::arithmetic_side_effects, reason = "arithmethic checked")]
504    pub fn increase_consumed_gas(&mut self, gas: u64) -> Result<(), ExceptionalHalt> {
505        self.gas_remaining -= gas as i64;
506
507        if self.gas_remaining < 0 {
508            return Err(ExceptionalHalt::OutOfGas);
509        }
510
511        Ok(())
512    }
513
514    /// EELS' `check_gas`: assert gas is available without consuming it.
515    #[inline(always)]
516    #[expect(clippy::as_conversions, reason = "remaining gas conversion")]
517    pub fn check_gas(&self, gas: u64) -> Result<(), ExceptionalHalt> {
518        if self.gas_remaining < 0 || (self.gas_remaining as u64) < gas {
519            return Err(ExceptionalHalt::OutOfGas);
520        }
521        Ok(())
522    }
523
524    pub fn set_code(&mut self, code: Code) -> Result<(), VMError> {
525        self.bytecode = code;
526        Ok(())
527    }
528}
529
530impl<'a> VM<'a> {
531    /// Adds current calframe to call_frames, sets current call frame to the passed callframe.
532    #[inline(always)]
533    pub fn add_callframe(&mut self, new_call_frame: CallFrame) {
534        // Reserve once on the first sub-call (p99 depth ~10, max 27): keeps the ~43% of txs that
535        // never make a call alloc-free (`call_frames` starts as `Vec::new()`), while avoiding the
536        // repeated reallocs a call-heavy tx would otherwise incur as depth grows.
537        if self.call_frames.is_empty() {
538            self.call_frames.reserve(8);
539        }
540        self.call_frames.push(new_call_frame);
541        #[allow(unsafe_code, reason = "just pushed, so the vec is not empty")]
542        unsafe {
543            std::mem::swap(
544                &mut self.current_call_frame,
545                self.call_frames.last_mut().unwrap_unchecked(),
546            );
547        }
548    }
549
550    #[inline(always)]
551    pub fn pop_call_frame(&mut self) -> Result<CallFrame, InternalError> {
552        let mut new = self.call_frames.pop().ok_or(InternalError::CallFrame)?;
553
554        std::mem::swap(&mut new, &mut self.current_call_frame);
555
556        Ok(new)
557    }
558
559    pub fn is_initial_call_frame(&self) -> bool {
560        self.call_frames.is_empty()
561    }
562
563    /// Restores the cache state to the state before changes made during a callframe.
564    pub fn restore_cache_state(&mut self) -> Result<(), VMError> {
565        let callframe_backup = self.current_call_frame.call_frame_backup.clone();
566        restore_cache_state(self.db, callframe_backup)
567    }
568
569    /// Like [`Self::restore_cache_state`] but moves the current frame's backup out instead of
570    /// cloning it. Only sound when nothing reads `call_frame_backup` afterward: the inner-call
571    /// revert in `handle_return` (the frame is popped right after, so its backup is dead), and
572    /// the top-level / invalid-tx revert when no `BackupHook` is installed (normal L1 block
573    /// execution, gated on `VM::preserve_top_level_backup`).
574    ///
575    /// When a `BackupHook` IS present (L2 / stateless) the top-level paths must keep cloning,
576    /// because `BackupHook::finalize` reads the backup to build the tx-level undo snapshot.
577    pub fn restore_cache_state_consuming(&mut self) -> Result<(), VMError> {
578        let callframe_backup = std::mem::take(&mut self.current_call_frame.call_frame_backup);
579        restore_cache_state(self.db, callframe_backup)
580    }
581
582    // The CallFrameBackup of the current callframe has to be merged with the backup of its parent, in the following way:
583    //   - For every account that's present in the parent backup, do nothing (i.e. keep the one that's already there).
584    //   - For every account that's NOT present in the parent backup but is on the child backup, add the child backup to it.
585    //   - Do the same for every individual storage slot.
586    pub fn merge_call_frame_backup_with_parent(
587        &mut self,
588        child_call_frame_backup: &CallFrameBackup,
589    ) -> Result<(), VMError> {
590        let parent_backup_accounts = &mut self
591            .current_call_frame
592            .call_frame_backup
593            .original_accounts_info;
594        for (address, account) in child_call_frame_backup.original_accounts_info.iter() {
595            if parent_backup_accounts.get(address).is_none() {
596                parent_backup_accounts.insert(*address, account.clone());
597            }
598        }
599
600        let parent_backup_storage = &mut self
601            .current_call_frame
602            .call_frame_backup
603            .original_account_storage_slots;
604        for (address, storage) in child_call_frame_backup
605            .original_account_storage_slots
606            .iter()
607        {
608            let parent_storage = parent_backup_storage.entry(*address).or_default();
609            for (key, value) in storage {
610                if parent_storage.get(key).is_none() {
611                    parent_storage.insert(*key, *value);
612                }
613            }
614        }
615
616        // Propagate code-cache insertions so a revert of the parent also
617        // evicts codes deployed by the (committed) child frame.
618        self.current_call_frame
619            .call_frame_backup
620            .inserted_code_hashes
621            .extend(child_call_frame_backup.inserted_code_hashes.iter().copied());
622
623        Ok(())
624    }
625
626    #[inline(always)]
627    #[expect(
628        clippy::arithmetic_side_effects,
629        reason = "pc bounded by padded bytecode len"
630    )]
631    pub fn advance_pc(&mut self) {
632        self.current_call_frame.pc += 1;
633    }
634}
635
636#[cfg(test)]
637mod tests {
638    use super::*;
639    use ethrex_common::types::AccountInfo;
640
641    #[test]
642    fn absorb_keeps_earliest_original_value() {
643        let addr = Address::from_low_u64_be(1);
644        let mut acc = CallFrameBackup::default();
645
646        let mut first = CallFrameBackup::default();
647        first
648            .original_account_storage_slots
649            .entry(addr)
650            .or_default()
651            .insert(H256::zero(), U256::from(10));
652
653        let mut second = CallFrameBackup::default();
654        second
655            .original_account_storage_slots
656            .entry(addr)
657            .or_default()
658            .insert(H256::zero(), U256::from(20));
659
660        acc.absorb(&first);
661        acc.absorb(&second);
662
663        // First-seen-wins: the earliest original (10) is preserved.
664        let value = acc
665            .original_account_storage_slots
666            .get(&addr)
667            .and_then(|slots| slots.get(&H256::zero()))
668            .copied();
669        assert_eq!(value, Some(U256::from(10)));
670    }
671
672    #[test]
673    fn absorb_keeps_earliest_account_info() {
674        let addr = Address::from_low_u64_be(2);
675        let mut acc = CallFrameBackup::default();
676
677        let first_acc = LevmAccount {
678            info: AccountInfo {
679                nonce: 1,
680                ..Default::default()
681            },
682            ..Default::default()
683        };
684        let mut first = CallFrameBackup::default();
685        first.original_accounts_info.insert(addr, first_acc);
686
687        let second_acc = LevmAccount {
688            info: AccountInfo {
689                nonce: 2,
690                ..Default::default()
691            },
692            ..Default::default()
693        };
694        let mut second = CallFrameBackup::default();
695        second.original_accounts_info.insert(addr, second_acc);
696
697        acc.absorb(&first);
698        acc.absorb(&second);
699
700        let nonce = acc.original_accounts_info.get(&addr).map(|a| a.info.nonce);
701        assert_eq!(nonce, Some(1));
702    }
703}
ethrex_levm/call_frame.rs

ethrex_levm/
call_frame.rs
