forest/rpc/methods/eth/trace/

state_diff.rs

// Copyright 2019-2026 ChainSafe Systems
// SPDX-License-Identifier: Apache-2.0, MIT

//! State diff computation for `trace_call` and related RPC methods.
//!
//! Compares pre- and post-execution actor states to produce per-account diffs
//! covering balance, nonce, code, and storage.

use super::super::EthBigInt;
use super::super::types::{EthAddress, EthHash};
use super::super::utils::{ActorStateEthExt as _, EvmStorageKamt, evm_kamt_config, live_evm_state};
use super::types::{AccountDiff, ChangedType, Delta, StateDiff};
use super::utils::{ZERO_HASH, u256_to_eth_hash};
use crate::prelude::*;
use crate::shim::actors::evm::U256;
use crate::shim::actors::is_evm_actor;
use crate::shim::state_tree::{ActorState, StateTree};
use ahash::{HashMap, HashSet};
use std::collections::BTreeMap;
use tracing::debug;

/// Build state diff by comparing pre and post-execution states for touched addresses.
pub fn build_state_diff<S: Blockstore, T: Blockstore>(
    store: &S,
    pre_state: &StateTree<T>,
    post_state: &StateTree<T>,
    touched_addresses: &HashSet<EthAddress>,
) -> anyhow::Result<StateDiff> {
    let mut state_diff = StateDiff::new();

    for eth_addr in touched_addresses {
        let fil_addr = eth_addr.to_filecoin_address()?;

        // Get actor state before and after
        let pre_actor = pre_state
            .get_actor(&fil_addr)
            .context("failed to get actor state")?;

        let post_actor = post_state
            .get_actor(&fil_addr)
            .context("failed to get actor state")?;

        let account_diff = build_account_diff(store, pre_actor.as_ref(), post_actor.as_ref())?;

        // Only include it if there were actual changes
        state_diff.insert_if_changed(*eth_addr, account_diff);
    }

    Ok(state_diff)
}

/// Build account diff by comparing pre and post actor states.
fn build_account_diff<DB: Blockstore>(
    store: &DB,
    pre_actor: Option<&ActorState>,
    post_actor: Option<&ActorState>,
) -> anyhow::Result<AccountDiff> {
    let mut diff = AccountDiff::default();

    // Compare balance
    let pre_balance = pre_actor.map(|a| EthBigInt::from(a.balance.atto()));
    let post_balance = post_actor.map(|a| EthBigInt::from(a.balance.atto()));
    diff.balance = Delta::from_comparison(pre_balance, post_balance);

    // Compare nonce
    let pre_nonce = pre_actor.map(|a| a.eth_nonce(store)).transpose()?;
    let post_nonce = post_actor.map(|a| a.eth_nonce(store)).transpose()?;
    diff.nonce = Delta::from_comparison(pre_nonce, post_nonce);

    // Compare code (bytecode for EVM actors)
    let pre_code = pre_actor
        .map(|a| a.eth_bytecode(store))
        .transpose()?
        .flatten();
    let post_code = post_actor
        .map(|a| a.eth_bytecode(store))
        .transpose()?
        .flatten();
    diff.code = Delta::from_comparison(pre_code, post_code);

    // Compare storage slots for EVM actors
    diff.storage = diff_evm_storage_for_actors(store, pre_actor, post_actor)?;

    Ok(diff)
}

/// Compute storage diff between pre and post actor states.
///
/// Uses different Delta types based on the scenario:
/// - Account created (None → EVM): storage slots are `Delta::Added`
/// - Account deleted (EVM → None): storage slots are `Delta::Removed`
/// - Account modified (EVM → EVM): storage slots are `Delta::Changed`
/// - Actor type changed (EVM ↔ non-EVM): treated as deletion + creation
/// - Contract self-destructed (EVM → tombstoned EVM): its storage reads as empty, so the slots are
///   `Delta::Changed` to zero
fn diff_evm_storage_for_actors<DB: Blockstore>(
    store: &DB,
    pre_actor: Option<&ActorState>,
    post_actor: Option<&ActorState>,
) -> anyhow::Result<BTreeMap<EthHash, Delta<EthHash>>> {
    let pre_is_evm = pre_actor.is_some_and(|a| is_evm_actor(&a.code));
    let post_is_evm = post_actor.is_some_and(|a| is_evm_actor(&a.code));

    // Extract storage entries from EVM actors (empty map for non-EVM or missing actors)
    let pre_entries = extract_evm_storage_entries(store, pre_actor);
    let post_entries = extract_evm_storage_entries(store, post_actor);

    // If both are empty, no storage diff
    if pre_entries.is_empty() && post_entries.is_empty() {
        return Ok(BTreeMap::new());
    }

    let mut diff = BTreeMap::new();

    match (pre_is_evm, post_is_evm) {
        (false, true) => {
            for (key_bytes, value) in &post_entries {
                let key_hash = EthHash(ethereum_types::H256(*key_bytes));
                diff.insert(key_hash, Delta::Added(u256_to_eth_hash(value)));
            }
        }
        (true, false) => {
            for (key_bytes, value) in &pre_entries {
                let key_hash = EthHash(ethereum_types::H256(*key_bytes));
                diff.insert(key_hash, Delta::Removed(u256_to_eth_hash(value)));
            }
        }
        (true, true) => {
            for (key_bytes, pre_value) in &pre_entries {
                let key_hash = EthHash(ethereum_types::H256(*key_bytes));
                let pre_hash = u256_to_eth_hash(pre_value);

                match post_entries.get(key_bytes) {
                    Some(post_value) if pre_value != post_value => {
                        // Value changed
                        diff.insert(
                            key_hash,
                            Delta::Changed(ChangedType {
                                from: pre_hash,
                                to: u256_to_eth_hash(post_value),
                            }),
                        );
                    }
                    Some(_) => {
                        // Value unchanged, skip
                    }
                    None => {
                        // Slot cleared (value → zero)
                        diff.insert(
                            key_hash,
                            Delta::Changed(ChangedType {
                                from: pre_hash,
                                to: ZERO_HASH,
                            }),
                        );
                    }
                }
            }

            // Check for newly written entries (zero → value)
            for (key_bytes, post_value) in &post_entries {
                if !pre_entries.contains_key(key_bytes) {
                    let key_hash = EthHash(ethereum_types::H256(*key_bytes));
                    diff.insert(
                        key_hash,
                        Delta::Changed(ChangedType {
                            from: ZERO_HASH,
                            to: u256_to_eth_hash(post_value),
                        }),
                    );
                }
            }
        }
        // Neither EVM: no storage diff
        (false, false) => {}
    }

    Ok(diff)
}

/// Extract all storage entries from an EVM actor's KAMT.
/// Returns an empty map if the actor is absent, not an EVM actor, self-destructed, or its state
/// cannot be loaded.
pub fn extract_evm_storage_entries<DB: Blockstore>(
    store: &DB,
    actor: Option<&ActorState>,
) -> HashMap<[u8; 32], U256> {
    let Some(actor) = actor else {
        return HashMap::default();
    };
    let evm_state = match live_evm_state(store, actor) {
        Ok(Some(state)) => state,
        // Not an EVM actor, or a dead (self-destructed) contract: its storage reads as empty.
        Ok(None) => return HashMap::default(),
        Err(e) => {
            debug!("failed to load EVM state for storage extraction: {e:#}");
            return HashMap::default();
        }
    };

    let storage_cid = evm_state.contract_state();
    let config = evm_kamt_config();

    let kamt = match EvmStorageKamt::load_with_config(&storage_cid, store, config) {
        Ok(k) => k,
        Err(e) => {
            debug!("failed to load storage KAMT: {e}");
            return HashMap::default();
        }
    };

    let mut entries = HashMap::default();
    if let Err(e) = kamt.for_each(|key, value| {
        entries.insert(key.to_big_endian(), *value);
        Ok(())
    }) {
        debug!("failed to iterate storage KAMT: {e}");
        return HashMap::default();
    }

    entries
}

// Compute the set of storage keys that differ between pre and post actor states.
pub fn diff_entry_keys(
    pre_entries: &HashMap<[u8; 32], U256>,
    post_entries: &HashMap<[u8; 32], U256>,
) -> HashSet<[u8; 32]> {
    let mut changed = HashSet::default();

    for (k, v) in pre_entries {
        match post_entries.get(k) {
            Some(pv) if pv == v => {} // unchanged
            _ => {
                changed.insert(*k);
            }
        }
    }

    for k in post_entries.keys() {
        if !pre_entries.contains_key(k) {
            changed.insert(*k);
        }
    }

    changed
}

#[cfg(test)]
mod tests {
    use super::super::test_helpers::*;
    use super::*;
    use crate::db::MemoryDB;
    use crate::rpc::eth::EthUint64;
    use crate::rpc::eth::types::EthBytes;
    use crate::shim::address::Address as FilecoinAddress;
    use crate::shim::econ::TokenAmount;
    use crate::shim::state_tree::StateTreeVersion;

    #[test]
    fn test_build_state_diff_empty_touched_addresses() {
        let trees = TestStateTrees::new().unwrap();
        let touched_addresses = HashSet::new();

        let state_diff = trees.build_diff(&touched_addresses).unwrap();

        // No addresses touched = empty state diff
        assert!(state_diff.0.is_empty());
    }

    #[test]
    fn test_build_state_diff_nonexistent_address() {
        let trees = TestStateTrees::new().unwrap();
        let mut touched_addresses = HashSet::new();
        touched_addresses.insert(create_masked_id_eth_address(9999));

        let state_diff = trees.build_diff(&touched_addresses).unwrap();

        // Address doesn't exist in either state, so no diff (both None = unchanged)
        assert!(state_diff.0.is_empty());
    }

    #[test]
    fn test_build_state_diff_balance_increase() {
        let actor_id = 1001u64;
        let pre_actor = create_test_actor(1000, 5);
        let post_actor = create_test_actor(2000, 5);
        let trees = TestStateTrees::with_changed_actor(actor_id, pre_actor, post_actor).unwrap();

        let mut touched_addresses = HashSet::new();
        touched_addresses.insert(create_masked_id_eth_address(actor_id));

        let state_diff = trees.build_diff(&touched_addresses).unwrap();

        assert_eq!(state_diff.0.len(), 1);
        let eth_addr = create_masked_id_eth_address(actor_id);
        let diff = state_diff.0.get(&eth_addr).unwrap();
        match &diff.balance {
            Delta::Changed(change) => {
                assert_eq!(change.from, EthBigInt::from(1000));
                assert_eq!(change.to, EthBigInt::from(2000));
            }
            _ => panic!("Expected Delta::Changed for balance"),
        }
        assert!(diff.nonce.is_unchanged());
    }

    #[test]
    fn test_build_state_diff_balance_decrease() {
        let actor_id = 1002u64;
        let pre_actor = create_test_actor(5000, 10);
        let post_actor = create_test_actor(3000, 10);
        let trees = TestStateTrees::with_changed_actor(actor_id, pre_actor, post_actor).unwrap();

        let mut touched_addresses = HashSet::new();
        touched_addresses.insert(create_masked_id_eth_address(actor_id));

        let state_diff = trees.build_diff(&touched_addresses).unwrap();

        let eth_addr = create_masked_id_eth_address(actor_id);
        let diff = state_diff.0.get(&eth_addr).unwrap();
        match &diff.balance {
            Delta::Changed(change) => {
                assert_eq!(change.from, EthBigInt::from(5000));
                assert_eq!(change.to, EthBigInt::from(3000));
            }
            _ => panic!("Expected Delta::Changed for balance"),
        }
        assert!(diff.nonce.is_unchanged());
    }

    #[test]
    fn test_build_state_diff_nonce_increment() {
        let actor_id = 1003u64;
        let pre_actor = create_test_actor(1000, 5);
        let post_actor = create_test_actor(1000, 6);
        let trees = TestStateTrees::with_changed_actor(actor_id, pre_actor, post_actor).unwrap();

        let mut touched_addresses = HashSet::new();
        touched_addresses.insert(create_masked_id_eth_address(actor_id));

        let state_diff = trees.build_diff(&touched_addresses).unwrap();

        let eth_addr = create_masked_id_eth_address(actor_id);
        let diff = state_diff.0.get(&eth_addr).unwrap();
        assert!(diff.balance.is_unchanged());
        match &diff.nonce {
            Delta::Changed(change) => {
                assert_eq!(change.from.0, 5);
                assert_eq!(change.to.0, 6);
            }
            _ => panic!("Expected Delta::Changed for nonce"),
        }
    }

    #[test]
    fn test_build_state_diff_both_balance_and_nonce_change() {
        let actor_id = 1004u64;
        let pre_actor = create_test_actor(10000, 100);
        let post_actor = create_test_actor(9000, 101);
        let trees = TestStateTrees::with_changed_actor(actor_id, pre_actor, post_actor).unwrap();

        let mut touched_addresses = HashSet::new();
        touched_addresses.insert(create_masked_id_eth_address(actor_id));

        let state_diff = trees.build_diff(&touched_addresses).unwrap();

        let eth_addr = create_masked_id_eth_address(actor_id);
        let diff = state_diff.0.get(&eth_addr).unwrap();
        match &diff.balance {
            Delta::Changed(change) => {
                assert_eq!(change.from, EthBigInt::from(10000));
                assert_eq!(change.to, EthBigInt::from(9000));
            }
            _ => panic!("Expected Delta::Changed for balance"),
        }
        match &diff.nonce {
            Delta::Changed(change) => {
                assert_eq!(change.from.0, 100);
                assert_eq!(change.to.0, 101);
            }
            _ => panic!("Expected Delta::Changed for nonce"),
        }
    }

    #[test]
    fn test_build_state_diff_account_creation() {
        let actor_id = 1005u64;
        let post_actor = create_test_actor(5000, 0);
        let trees = TestStateTrees::with_created_actor(actor_id, post_actor).unwrap();

        let mut touched_addresses = HashSet::new();
        touched_addresses.insert(create_masked_id_eth_address(actor_id));

        let state_diff = trees.build_diff(&touched_addresses).unwrap();

        let eth_addr = create_masked_id_eth_address(actor_id);
        let diff = state_diff.0.get(&eth_addr).unwrap();
        match &diff.balance {
            Delta::Added(balance) => {
                assert_eq!(balance, &EthBigInt::from(5000));
            }
            _ => panic!("Expected Delta::Added for balance"),
        }
        match &diff.nonce {
            Delta::Added(nonce) => {
                assert_eq!(nonce.0, 0);
            }
            _ => panic!("Expected Delta::Added for nonce"),
        }
    }

    #[test]
    fn test_build_state_diff_account_deletion() {
        let actor_id = 1006u64;
        let pre_actor = create_test_actor(3000, 10);
        let trees = TestStateTrees::with_deleted_actor(actor_id, pre_actor).unwrap();

        let mut touched_addresses = HashSet::new();
        touched_addresses.insert(create_masked_id_eth_address(actor_id));

        let state_diff = trees.build_diff(&touched_addresses).unwrap();

        let eth_addr = create_masked_id_eth_address(actor_id);
        let diff = state_diff.0.get(&eth_addr).unwrap();
        match &diff.balance {
            Delta::Removed(balance) => {
                assert_eq!(balance, &EthBigInt::from(3000));
            }
            _ => panic!("Expected Delta::Removed for balance"),
        }
        match &diff.nonce {
            Delta::Removed(nonce) => {
                assert_eq!(nonce.0, 10);
            }
            _ => panic!("Expected Delta::Removed for nonce"),
        }
    }

    #[test]
    fn test_build_state_diff_multiple_addresses() {
        let store = Arc::new(MemoryDB::default());
        let mut pre_state = StateTree::new(&store, StateTreeVersion::V5).unwrap();
        let mut post_state = StateTree::new(&store, StateTreeVersion::V5).unwrap();

        // Actor 1: balance increase
        let addr1 = FilecoinAddress::new_id(2001);
        pre_state
            .set_actor(&addr1, create_test_actor(1000, 0))
            .unwrap();
        post_state
            .set_actor(&addr1, create_test_actor(2000, 0))
            .unwrap();

        // Actor 2: nonce increase
        let addr2 = FilecoinAddress::new_id(2002);
        pre_state
            .set_actor(&addr2, create_test_actor(500, 5))
            .unwrap();
        post_state
            .set_actor(&addr2, create_test_actor(500, 6))
            .unwrap();

        // Actor 3: no change (should not appear in diff)
        let addr3 = FilecoinAddress::new_id(2003);
        pre_state
            .set_actor(&addr3, create_test_actor(100, 1))
            .unwrap();
        post_state
            .set_actor(&addr3, create_test_actor(100, 1))
            .unwrap();

        let mut touched_addresses = HashSet::new();
        touched_addresses.insert(create_masked_id_eth_address(2001));
        touched_addresses.insert(create_masked_id_eth_address(2002));
        touched_addresses.insert(create_masked_id_eth_address(2003));

        let state_diff =
            build_state_diff(store.as_ref(), &pre_state, &post_state, &touched_addresses).unwrap();

        assert_eq!(state_diff.0.len(), 2);
        assert!(
            state_diff
                .0
                .contains_key(&create_masked_id_eth_address(2001))
        );
        assert!(
            state_diff
                .0
                .contains_key(&create_masked_id_eth_address(2002))
        );
        assert!(
            !state_diff
                .0
                .contains_key(&create_masked_id_eth_address(2003))
        );
    }

    #[test]
    fn test_build_state_diff_evm_actor_scenarios() {
        struct TestCase {
            name: &'static str,
            pre: Option<(u64, u64, Option<&'static [u8]>)>, // balance, nonce, bytecode
            post: Option<(u64, u64, Option<&'static [u8]>)>,
            expected_balance: Delta<EthBigInt>,
            expected_nonce: Delta<EthUint64>,
            expected_code: Delta<EthBytes>,
        }

        let bytecode1: &[u8] = &[0x60, 0x80, 0x60, 0x40, 0x52];
        let bytecode2: &[u8] = &[0x60, 0x80, 0x60, 0x40, 0x52, 0x00];

        let cases = vec![
            TestCase {
                name: "No change",
                pre: Some((1000, 5, Some(bytecode1))),
                post: Some((1000, 5, Some(bytecode1))),
                expected_balance: Delta::Unchanged,
                expected_nonce: Delta::Unchanged,
                expected_code: Delta::Unchanged,
            },
            TestCase {
                name: "Balance increase",
                pre: Some((1000, 5, Some(bytecode1))),
                post: Some((2000, 5, Some(bytecode1))),
                expected_balance: Delta::Changed(ChangedType {
                    from: EthBigInt::from(1000),
                    to: EthBigInt::from(2000),
                }),
                expected_nonce: Delta::Unchanged,
                expected_code: Delta::Unchanged,
            },
            TestCase {
                name: "Nonce increment",
                pre: Some((1000, 5, Some(bytecode1))),
                post: Some((1000, 6, Some(bytecode1))),
                expected_balance: Delta::Unchanged,
                expected_nonce: Delta::Changed(ChangedType {
                    from: EthUint64(5),
                    to: EthUint64(6),
                }),
                expected_code: Delta::Unchanged,
            },
            TestCase {
                name: "Bytecode change",
                pre: Some((1000, 5, Some(bytecode1))),
                post: Some((1000, 5, Some(bytecode2))),
                expected_balance: Delta::Unchanged,
                expected_nonce: Delta::Unchanged,
                expected_code: Delta::Changed(ChangedType {
                    from: EthBytes(bytecode1.to_vec()),
                    to: EthBytes(bytecode2.to_vec()),
                }),
            },
            TestCase {
                name: "Balance and Nonce change",
                pre: Some((1000, 5, Some(bytecode1))),
                post: Some((2000, 6, Some(bytecode1))),
                expected_balance: Delta::Changed(ChangedType {
                    from: EthBigInt::from(1000),
                    to: EthBigInt::from(2000),
                }),
                expected_nonce: Delta::Changed(ChangedType {
                    from: EthUint64(5),
                    to: EthUint64(6),
                }),
                expected_code: Delta::Unchanged,
            },
            TestCase {
                name: "Creation",
                pre: None,
                post: Some((5000, 0, Some(bytecode1))),
                expected_balance: Delta::Added(EthBigInt::from(5000)),
                expected_nonce: Delta::Added(EthUint64(0)),
                expected_code: Delta::Added(EthBytes(bytecode1.to_vec())),
            },
            TestCase {
                name: "Deletion",
                pre: Some((3000, 10, Some(bytecode1))),
                post: None,
                expected_balance: Delta::Removed(EthBigInt::from(3000)),
                expected_nonce: Delta::Removed(EthUint64(10)),
                expected_code: Delta::Removed(EthBytes(bytecode1.to_vec())),
            },
        ];

        for case in cases {
            let store = Arc::new(MemoryDB::default());
            let actor_id = 10000u64; // arbitrary ID

            let pre_actor = case.pre.and_then(|(bal, nonce, code)| {
                create_evm_actor_with_bytecode(&store, bal, 0, nonce, code)
            });
            let post_actor = case.post.and_then(|(bal, nonce, code)| {
                create_evm_actor_with_bytecode(&store, bal, 0, nonce, code)
            });

            let mut pre_state = StateTree::new(&store, StateTreeVersion::V5).unwrap();
            let mut post_state = StateTree::new(&store, StateTreeVersion::V5).unwrap();
            let addr = FilecoinAddress::new_id(actor_id);

            if let Some(actor) = pre_actor {
                pre_state.set_actor(&addr, actor).unwrap();
            }
            if let Some(actor) = post_actor {
                post_state.set_actor(&addr, actor).unwrap();
            }

            let mut touched_addresses = HashSet::new();
            touched_addresses.insert(create_masked_id_eth_address(actor_id));

            let state_diff =
                build_state_diff(store.as_ref(), &pre_state, &post_state, &touched_addresses)
                    .unwrap();

            if case.expected_balance == Delta::Unchanged
                && case.expected_nonce == Delta::Unchanged
                && case.expected_code == Delta::Unchanged
            {
                assert!(
                    state_diff.0.is_empty(),
                    "Test case '{}' failed: expected empty diff",
                    case.name
                );
            } else {
                let eth_addr = create_masked_id_eth_address(actor_id);
                let diff = state_diff.0.get(&eth_addr).unwrap_or_else(|| {
                    panic!("Test case '{}' failed: missing diff entry", case.name)
                });

                assert_eq!(
                    diff.balance, case.expected_balance,
                    "Test case '{}' failed: balance mismatch",
                    case.name
                );
                assert_eq!(
                    diff.nonce, case.expected_nonce,
                    "Test case '{}' failed: nonce mismatch",
                    case.name
                );
                assert_eq!(
                    diff.code, case.expected_code,
                    "Test case '{}' failed: code mismatch",
                    case.name
                );
            }
        }
    }

    #[test]
    fn test_build_state_diff_non_evm_actor_no_code() {
        // Non-EVM actors should have no code in their diff
        let actor_id = 4005u64;
        let pre_actor = create_test_actor(1000, 5);
        let post_actor = create_test_actor(2000, 6);
        let trees = TestStateTrees::with_changed_actor(actor_id, pre_actor, post_actor).unwrap();

        let mut touched_addresses = HashSet::new();
        touched_addresses.insert(create_masked_id_eth_address(actor_id));

        let state_diff = trees.build_diff(&touched_addresses).unwrap();

        let eth_addr = create_masked_id_eth_address(actor_id);
        let diff = state_diff.0.get(&eth_addr).unwrap();

        // Balance and nonce should change
        assert!(!diff.balance.is_unchanged());
        assert!(!diff.nonce.is_unchanged());

        // Code should be unchanged (None -> None for non-EVM actors)
        assert!(diff.code.is_unchanged());
    }

    #[test]
    fn test_actor_nonce_non_evm() {
        let store = MemoryDB::default();
        let actor = create_test_actor(1000, 42);
        let nonce = actor.eth_nonce(&store).unwrap();
        assert_eq!(nonce.0, 42);
    }

    #[test]
    fn test_actor_nonce_evm() {
        let store = Arc::new(MemoryDB::default());
        let actor = create_evm_actor_with_bytecode(&store, 1000, 0, 7, Some(&[0x60]))
            .expect("failed to create EVM actor fixture");
        let nonce = actor.eth_nonce(store.as_ref()).unwrap();
        // EVM actors use the EVM nonce field, not the actor sequence
        assert_eq!(nonce.0, 7);
    }

    #[test]
    fn test_actor_bytecode_non_evm() {
        let store = MemoryDB::default();
        let actor = create_test_actor(1000, 0);
        assert!(actor.eth_bytecode(&store).unwrap().is_none());
    }

    #[test]
    fn test_actor_bytecode_evm() {
        let store = Arc::new(MemoryDB::default());
        let bytecode = &[0x60, 0x80, 0x60, 0x40, 0x52];
        let actor = create_evm_actor_with_bytecode(&store, 1000, 0, 1, Some(bytecode))
            .expect("failed to create EVM actor fixture");
        let result = actor.eth_bytecode(store.as_ref()).unwrap();
        assert_eq!(result, Some(EthBytes(bytecode.to_vec())));
    }

    #[test]
    fn test_actor_bytecode_evm_no_bytecode() {
        let store = Arc::new(MemoryDB::default());
        let actor = create_evm_actor_with_bytecode(&store, 1000, 0, 1, None)
            .expect("failed to create EVM actor fixture");
        // No bytecode stored => None (Cid::default() won't resolve to raw data)
        let result = actor.eth_bytecode(store.as_ref()).unwrap();
        assert!(result.is_none());
    }

    #[test]
    fn test_actor_bytecode_evm_tombstoned() {
        let store = Arc::new(MemoryDB::default());
        let actor =
            create_tombstoned_evm_actor(&store, &[0x60, 0x80, 0x60, 0x40, 0x52], 0, Cid::default())
                .expect("failed to create tombstoned EVM actor fixture");
        // A self-destructed contract reports no code even though its bytecode is present,
        // matching the EVM actor's GetBytecode.
        assert!(actor.eth_bytecode(store.as_ref()).unwrap().is_none());
    }

    /// Builds a storage KAMT holding `slot -> value` and returns its root.
    fn storage_with_slot(store: &MemoryDB, slot: u64, value: u64) -> Cid {
        let mut kamt = EvmStorageKamt::new_with_config(store, evm_kamt_config());
        kamt.set(U256::from(slot), U256::from(value)).unwrap();
        kamt.flush().unwrap()
    }

    /// A self-destructed contract reports a zero nonce even though its state carries one, mirroring
    /// Lotus's `itests/eth_bytecode_test.go` (nonce is 1 after deploy, zero after `destroy()`).
    #[test]
    fn test_actor_nonce_evm_tombstoned() {
        let store = MemoryDB::default();
        // Actor sequence 0 but EVM nonce 7, so this also pins that the EVM nonce is what's read.
        let alive = create_evm_actor_with_bytecode(&store, 0, 0, 7, Some(&[0x60]))
            .expect("failed to create EVM actor fixture");
        assert_eq!(alive.eth_nonce(&store).unwrap().0, 7);

        let mut dead = create_tombstoned_evm_actor(&store, &[0x60], 7, Cid::default())
            .expect("failed to create tombstoned EVM actor fixture");
        // Nonzero sequence, so falling through to the non-EVM branch would not also yield 0.
        dead.sequence = 9;
        assert_eq!(dead.eth_nonce(&store).unwrap().0, 0);
    }

    /// A self-destructed contract's storage reads as empty, matching the EVM actor's `System::load`.
    #[test]
    fn test_extract_evm_storage_entries_tombstoned() {
        let store = MemoryDB::default();
        let contract_state = storage_with_slot(&store, 5, 42);

        // Sanity: the same KAMT is visible while the contract is alive.
        let alive = create_evm_actor_with_storage(&store, contract_state)
            .expect("failed to create EVM actor fixture");
        assert_eq!(
            extract_evm_storage_entries(&store, Some(&alive)).len(),
            1,
            "live contract must expose its slots"
        );

        let dead = create_tombstoned_evm_actor(&store, &[0x60], 0, contract_state)
            .expect("failed to create tombstoned EVM actor fixture");
        assert!(
            extract_evm_storage_entries(&store, Some(&dead)).is_empty(),
            "self-destructed contract must read as empty storage"
        );
    }

    /// An absent actor, or one whose EVM state cannot be loaded, reads as empty storage.
    #[test]
    fn test_extract_evm_storage_entries_absent_or_unloadable() {
        let store = MemoryDB::default();
        assert!(extract_evm_storage_entries(&store, None).is_empty());

        // EVM code CID, but the state block is not in the store.
        let unloadable = ActorState::new(
            get_evm_actor_code_cid().expect("bundled EVM actor code CID"),
            Cid::default(),
            TokenAmount::default(),
            0,
            None,
        );
        assert!(
            extract_evm_storage_entries(&store, Some(&unloadable)).is_empty(),
            "unloadable EVM state must read as empty storage"
        );
    }

    /// Self-destructing clears the slots, so the diff reports them going to zero rather than
    /// reporting no change at all.
    #[test]
    fn test_diff_evm_storage_reports_slots_cleared_on_selfdestruct() {
        let store = MemoryDB::default();
        let contract_state = storage_with_slot(&store, 5, 42);
        let pre = create_evm_actor_with_storage(&store, contract_state)
            .expect("failed to create EVM actor fixture");
        let post = create_tombstoned_evm_actor(&store, &[0x60], 0, contract_state)
            .expect("failed to create tombstoned EVM actor fixture");

        let diff = diff_evm_storage_for_actors(&store, Some(&pre), Some(&post)).unwrap();
        let slot = u256_to_eth_hash(&U256::from(5u64));
        assert_eq!(
            diff.get(&slot),
            Some(&Delta::Changed(ChangedType {
                from: u256_to_eth_hash(&U256::from(42u64)),
                to: ZERO_HASH,
            })),
            "destroyed contract's slot must be reported as cleared"
        );
    }

    #[test]
    fn test_diff_entry_keys_both_empty() {
        let pre = HashMap::default();
        let post = HashMap::default();
        let keys = diff_entry_keys(&pre, &post);
        assert!(keys.is_empty());
    }

    #[test]
    fn test_diff_entry_keys_non_evm_actors() {
        let store = MemoryDB::default();
        let pre = create_test_actor(1000, 5);
        let post = create_test_actor(2000, 6);
        // Non-EVM actors have no EVM storage, so no changed keys
        let pre_entries = extract_evm_storage_entries(&store, Some(&pre));
        let post_entries = extract_evm_storage_entries(&store, Some(&post));
        let keys = diff_entry_keys(&pre_entries, &post_entries);
        assert!(keys.is_empty());
    }

    #[test]
    fn test_diff_entry_keys_pre_none_post_non_evm() {
        let store = MemoryDB::default();
        let post = create_test_actor(1000, 0);
        let pre_entries = extract_evm_storage_entries(&store, None);
        let post_entries = extract_evm_storage_entries(&store, Some(&post));
        let keys = diff_entry_keys(&pre_entries, &post_entries);
        assert!(keys.is_empty());
    }
}