diff --git a/Cargo.lock b/Cargo.lock
index 5fd6a45bb..de0143284 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1104,6 +1104,7 @@ checksum = "1bc2832c24239b0141d5674bb9174f9d68a8b5b3f2753311927c172ca46f7e9c"
 dependencies = [
  "funty",
  "radium",
+ "serde",
  "tap",
  "wyz",
 ]
@@ -1856,6 +1857,9 @@ name = "either"
 version = "1.13.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "60b1af1c220855b6ceac025d3f6ecdd2b7c4894bfe9cd9bda4fbb4bc7c0d4cf0"
+dependencies = [
+ "serde",
+]
 
 [[package]]
 name = "elliptic-curve"
@@ -2033,8 +2037,11 @@ dependencies = [
  "alloy",
  "alloy-compat",
  "anyhow",
+ "bitflags 2.6.0",
  "bitvec",
  "bytes",
+ "ciborium",
+ "ciborium-io",
  "copyvec",
  "criterion",
  "either",
@@ -2050,6 +2057,7 @@ dependencies = [
  "mpt_trie",
  "num",
  "num-bigint",
+ "nunny",
  "once_cell",
  "pest",
  "pest_derive",
@@ -2066,6 +2074,7 @@ dependencies = [
  "serde_json",
  "sha2",
  "smt_trie",
+ "stackstack",
  "starky",
  "static_assertions",
  "thiserror",
@@ -2075,6 +2084,7 @@ dependencies = [
  "tracing",
  "u4",
  "url",
+ "winnow",
  "zk_evm_common",
  "zk_evm_proc_macro",
 ]
@@ -4684,6 +4694,8 @@ version = "0.1.1"
 dependencies = [
  "ethereum-types",
  "hex-literal",
+ "log",
+ "mpt_trie",
  "plonky2",
  "rand",
  "serde",
diff --git a/Cargo.toml b/Cargo.toml
index f8c6be0f7..62661c474 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -40,7 +40,7 @@ anyhow = "1.0.86"
 async-stream = "0.3.5"
 axum = "0.7.5"
 bitflags = "2.5.0"
-bitvec = "1.0.1"
+bitvec = { version = "1.0.1", features = ["serde"] }
 bytes = "1.6.0"
 ciborium = "0.2.2"
 ciborium-io = "0.2.2"
@@ -49,7 +49,7 @@ alloy-compat = "0.1.0"
 copyvec = "0.2.0"
 criterion = "0.5.1"
 dotenvy = "0.15.7"
-either = "1.12.0"
+either = { version = "1.12.0", features = ["serde"] }
 enum-as-inner = "0.6.0"
 env_logger = "0.11.3"
 eth_trie = "0.4.0"
diff --git a/evm_arithmetization/Cargo.toml b/evm_arithmetization/Cargo.toml
index 22a40013f..44016835e 100644
--- a/evm_arithmetization/Cargo.toml
+++ b/evm_arithmetization/Cargo.toml
@@ -18,8 +18,11 @@ keywords.workspace = true
 alloy.workspace = true
 alloy-compat.workspace = true
 anyhow.workspace = true
+bitflags.workspace = true
 bitvec.workspace = true
 bytes.workspace = true
+ciborium.workspace = true
+ciborium-io.workspace = true
 copyvec.workspace = true
 either.workspace = true
 env_logger.workspace = true
@@ -34,6 +37,7 @@ log.workspace = true
 mpt_trie.workspace = true
 num.workspace = true
 num-bigint.workspace = true
+nunny.workspace = true
 once_cell.workspace = true
 pest.workspace = true
 pest_derive.workspace = true
@@ -48,7 +52,8 @@ serde = { workspace = true, features = ["derive"] }
 serde-big-array.workspace = true
 serde_json.workspace = true
 sha2.workspace = true
-smt_trie = { workspace = true }
+smt_trie.workspace = true
+stackstack = "0.3.0"
 starky = { workspace = true, features = ["parallel"] }
 static_assertions.workspace = true
 thiserror.workspace = true
@@ -58,6 +63,7 @@ tower-lsp = "0.20.0"
 tracing.workspace = true
 u4.workspace = true
 url.workspace = true
+winnow.workspace = true
 zk_evm_common.workspace = true
 zk_evm_proc_macro.workspace = true
 
diff --git a/evm_arithmetization/benches/fibonacci_25m_gas.rs b/evm_arithmetization/benches/fibonacci_25m_gas.rs
index 2242b3049..360e54344 100644
--- a/evm_arithmetization/benches/fibonacci_25m_gas.rs
+++ b/evm_arithmetization/benches/fibonacci_25m_gas.rs
@@ -8,18 +8,25 @@ use std::collections::HashMap;
 use std::str::FromStr;
 
 use criterion::{criterion_group, criterion_main, BatchSize, BenchmarkId, Criterion};
+use either::Either;
 use env_logger::{try_init_from_env, Env, DEFAULT_FILTER_ENV};
-use ethereum_types::{Address, H256, U256};
+#[cfg(feature = "cdk_erigon")]
+use ethereum_types::H160;
+use ethereum_types::{Address, BigEndianHash, H256, U256};
 use evm_arithmetization::cpu::kernel::aggregator::KERNEL;
 use evm_arithmetization::cpu::kernel::opcodes::{get_opcode, get_push_opcode};
-use evm_arithmetization::generation::mpt::{AccountRlp, LegacyReceiptRlp};
+use evm_arithmetization::generation::mpt::{Account, EitherAccount, LegacyReceiptRlp, MptAccount};
 use evm_arithmetization::generation::{GenerationInputs, TrieInputs};
 use evm_arithmetization::proof::{BlockHashes, BlockMetadata, TrieRoots};
 use evm_arithmetization::prover::testing::simulate_execution;
+#[cfg(not(feature = "cdk_erigon"))]
+use evm_arithmetization::testing_utils::get_state_world;
+#[cfg(feature = "eth_mainnet")]
 use evm_arithmetization::testing_utils::{
     beacon_roots_account_nibbles, beacon_roots_contract_from_storage,
     preinitialized_state_and_storage_tries, update_beacon_roots_account_storage,
 };
+use evm_arithmetization::world::{StateWorld, World};
 use evm_arithmetization::{Node, EMPTY_CONSOLIDATED_BLOCKHASH};
 use hex_literal::hex;
 use keccak_hash::keccak;
@@ -27,6 +34,12 @@ use mpt_trie::nibbles::Nibbles;
 use mpt_trie::partial_trie::{HashedPartialTrie, PartialTrie};
 use plonky2::field::goldilocks_field::GoldilocksField;
 use plonky2::field::types::Field;
+#[cfg(feature = "cdk_erigon")]
+use plonky2::field::types::PrimeField64;
+use smt_trie::code::hash_bytecode_h256;
+#[cfg(feature = "cdk_erigon")]
+use smt_trie::keys::{key_balance, key_code_length};
+use smt_trie::utils::hashout2u;
 
 type F = GoldilocksField;
 
@@ -52,6 +65,8 @@ fn criterion_benchmark(c: &mut Criterion) {
 }
 
 fn prepare_setup() -> anyhow::Result<GenerationInputs<F>> {
+    let state_world = StateWorld::default();
+
     let sender = hex!("8943545177806ED17B9F23F0a21ee5948eCaa776");
     let to = hex!("159271B89fea49aF29DFaf8b4eCE7D042D5d6f07");
 
@@ -71,36 +86,91 @@ fn prepare_setup() -> anyhow::Result<GenerationInputs<F>> {
     let code = [
         push1, 1, push1, 1, jumpdest, dup2, add, swap1, push4, 0, 0, 0, 4, jump,
     ];
-    let code_hash = keccak(code);
+
+    let code_hash = if cfg!(feature = "cdk_erigon") {
+        hash_bytecode_h256(&code)
+    } else {
+        keccak(&code)
+    };
 
     let empty_trie_root = HashedPartialTrie::from(Node::Empty).hash();
 
-    let sender_account_before = AccountRlp {
-        nonce: 169.into(),
-        balance: U256::from_dec_str("999999999998417410153631615")?,
-        storage_root: empty_trie_root,
-        code_hash: keccak(vec![]),
+    let sender_account_before = if cfg!(feature = "cdk_erigon") {
+        Either::Right(SmtAccount {
+            nonce: 169.into(),
+            balance: U256::from_dec_str("999999999998417410153631615")?,
+            code_hash: state_world.hash_code(&[]).into_uint(),
+            code_length: 0.into(),
+        })
+    } else {
+        Either::Left(MptAccount {
+            nonce: 169.into(),
+            balance: U256::from_dec_str("999999999998417410153631615")?,
+            storage_root: empty_trie_root,
+            code_hash: keccak(vec![]),
+        })
     };
-    let to_account_before = AccountRlp {
-        nonce: 1.into(),
-        balance: 0.into(),
-        storage_root: empty_trie_root,
-        code_hash,
+
+    let to_account_before = if cfg!(feature = "cdk_erigon") {
+        EitherAccount(Either::Right(SmtAccount {
+            nonce: 1.into(),
+            balance: 0.into(),
+            code_hash: code_hash.into_uint(),
+            code_length: code.len().into(),
+        }))
+    } else {
+        EitherAccount(Either::Left(MptAccount {
+            nonce: 1.into(),
+            balance: 0.into(),
+            storage_root: empty_trie_root,
+            code_hash,
+        }))
     };
 
-    let (mut state_trie_before, mut storage_tries) = preinitialized_state_and_storage_tries()?;
+    let mut state_trie_before = StateWorld::default();
+    #[cfg(feature = "eth_mainnet")]
+    let (mut state_trie_before_hashed, mut storage_tries) =
+        preinitialized_state_and_storage_tries()?;
+    #[cfg(feature = "eth_mainnet")]
     let mut beacon_roots_account_storage = storage_tries[0].1.clone();
-    state_trie_before.insert(sender_nibbles, rlp::encode(&sender_account_before).to_vec())?;
-    state_trie_before.insert(to_nibbles, rlp::encode(&to_account_before).to_vec())?;
+    #[cfg(feature = "eth_mainnet")]
+    {
+        let sender_account_before_mpt =
+            sender_account_before.expect_left("The sender account is an MPT.");
+        state_trie_before_hashed.insert(
+            sender_nibbles,
+            rlp::encode(&sender_account_before_mpt).to_vec(),
+        )?;
+        state_trie_before_hashed.insert(to_nibbles, to_account_before.rlp_encode().to_vec())?;
+
+        storage_tries.push((sender_state_key, Node::Empty.into()));
+        storage_tries.push((to_state_key, Node::Empty.into()));
+        state_trie_before = get_state_world(state_trie_before_hashed, storage_tries);
+    }
 
-    storage_tries.push((sender_state_key, Node::Empty.into()));
-    storage_tries.push((to_state_key, Node::Empty.into()));
+    #[cfg(feature = "cdk_erigon")]
+    {
+        let sender_account_before_smt =
+            sender_account_before.expect_right("The sender account is an SMT.");
+        let to_account_before_smt = to_account_before.as_smt_account();
+        set_account(
+            &mut state_trie_before,
+            H160(sender),
+            &sender_account_before_smt,
+            &vec![],
+        );
+        set_account(
+            &mut state_trie_before,
+            H160(to),
+            &to_account_before_smt,
+            &code,
+        );
+    }
 
     let tries_before = TrieInputs {
         state_trie: state_trie_before,
         transactions_trie: Node::Empty.into(),
         receipts_trie: Node::Empty.into(),
-        storage_tries,
     };
 
     let gas_used = U256::from(0x17d7840_u32);
@@ -123,31 +193,79 @@ fn prepare_setup() -> anyhow::Result<GenerationInputs<F>> {
     };
 
     let mut contract_code = HashMap::new();
-    contract_code.insert(keccak(vec![]), vec![]);
-    contract_code.insert(code_hash, code.to_vec());
+    // TODO(Robin) Review this
+    if cfg!(feature = "eth_mainnet") {
+        contract_code.insert(keccak(vec![]), vec![]);
+        contract_code.insert(keccak(code), code.to_vec());
+    } else {
+        contract_code.insert(hash_bytecode_h256(&[]), vec![]);
+        contract_code.insert(hash_bytecode_h256(&code), code.to_vec());
+    }
 
-    let sender_account_after = AccountRlp {
-        balance: sender_account_before.balance - value - gas_used * block_metadata.block_base_fee,
-        nonce: sender_account_before.nonce + 1,
-        ..sender_account_before
+    let sender_account_after = if cfg!(feature = "cdk_erigon") {
+        let sender_account_before_smt =
+            sender_account_before.expect_right("cdk_erigon expects SMTs.");
+        EitherAccount(Either::Right(SmtAccount {
+            balance: sender_account_before_smt.get_balance()
+                - value
+                - gas_used * block_metadata.block_base_fee,
+            nonce: sender_account_before_smt.get_nonce() + 1,
+            ..sender_account_before_smt
+        }))
+    } else {
+        let sender_account_before_mpt =
+            sender_account_before.expect_left("eth_mainnet expects MPTs.");
+        EitherAccount(Either::Left(MptAccount {
+            balance: sender_account_before_mpt.get_balance()
+                - value
+                - gas_used * block_metadata.block_base_fee,
+            nonce: sender_account_before_mpt.get_nonce() + 1,
+            ..sender_account_before_mpt
+        }))
     };
-    let to_account_after = to_account_before;
+    let to_account_after = &to_account_before;
 
-    let mut expected_state_trie_after = HashedPartialTrie::from(Node::Empty);
-    expected_state_trie_after
-        .insert(sender_nibbles, rlp::encode(&sender_account_after).to_vec())?;
-    expected_state_trie_after.insert(to_nibbles, rlp::encode(&to_account_after).to_vec())?;
+    let mut expected_state_trie_after = StateWorld::default();
+    #[cfg(feature = "eth_mainnet")]
+    let mut expected_state_trie_after_hashed = HashedPartialTrie::from(Node::Empty);
+    #[cfg(feature = "eth_mainnet")]
+    {
+        expected_state_trie_after_hashed
+            .insert(sender_nibbles, sender_account_after.rlp_encode().to_vec())?;
+        expected_state_trie_after_hashed
+            .insert(to_nibbles, to_account_after.rlp_encode().to_vec())?;
 
-    update_beacon_roots_account_storage(
-        &mut beacon_roots_account_storage,
-        block_metadata.block_timestamp,
-        block_metadata.parent_beacon_block_root,
-    )?;
-    let beacon_roots_account = beacon_roots_contract_from_storage(&beacon_roots_account_storage);
-    expected_state_trie_after.insert(
-        beacon_roots_account_nibbles(),
-        rlp::encode(&beacon_roots_account).to_vec(),
-    )?;
+        update_beacon_roots_account_storage(
+            &mut beacon_roots_account_storage,
+            block_metadata.block_timestamp,
+            block_metadata.parent_beacon_block_root,
+        )?;
+        let beacon_roots_account =
+            beacon_roots_contract_from_storage(&beacon_roots_account_storage);
+        expected_state_trie_after_hashed.insert(
+            beacon_roots_account_nibbles(),
+            rlp::encode(&beacon_roots_account).to_vec(),
+        )?;
+        expected_state_trie_after = get_state_world(expected_state_trie_after_hashed, vec![]);
+    }
+
+    #[cfg(feature = "cdk_erigon")]
+    {
+        let sender_account_after_smt = sender_account_after.as_smt_account();
+        let to_account_after_smt = to_account_after.as_smt_account();
+        set_account(
+            &mut expected_state_trie_after,
+            H160(sender),
+            &sender_account_after_smt,
+            &vec![],
+        );
+        set_account(
+            &mut expected_state_trie_after,
+            H160(to),
+            &to_account_after_smt,
+            &code,
+        );
+    }
 
     let receipt_0 = LegacyReceiptRlp {
         status: false,
@@ -166,8 +284,23 @@ fn prepare_setup() -> anyhow::Result<GenerationInputs<F>> {
     }
     .into();
 
+    let state_root = if cfg!(feature = "eth_mainnet") {
+        expected_state_trie_after
+            .state
+            .expect_left("eth_mainnet expects MPTs.")
+            .state_trie()
+            .hash()
+    } else {
+        H256::from_uint(&hashout2u(
+            expected_state_trie_after
+                .state
+                .expect_right("cdk_erigon expects SMTs.")
+                .as_smt()
+                .root,
+        ))
+    };
     let trie_roots_after = TrieRoots {
-        state_root: expected_state_trie_after.hash(),
+        state_root,
         transactions_root: transactions_trie.hash(),
         receipts_root: receipts_trie.hash(),
     };
@@ -201,3 +334,29 @@ fn init_logger() {
 
 criterion_group!(benches, criterion_benchmark);
 criterion_main!(benches);
+
+use evm_arithmetization::generation::mpt::SmtAccount;
+
+#[cfg(feature = "cdk_erigon")]
+fn set_account(world: &mut StateWorld, addr: Address, account: &SmtAccount, code: &[u8]) {
+    use evm_arithmetization::world::World;
+
+    let key = key_balance(addr);
+    log::debug!(
+        "setting {:?} balance to {:?}, the key is {:?}",
+        addr,
+        account.get_balance(),
+        U256(std::array::from_fn(|i| key.0[i].to_canonical_u64()))
+    );
+    if let Either::Right(ref mut smt_state) = world.state {
+        smt_state.update_balance(addr, |b| *b = account.get_balance());
+        smt_state.update_nonce(addr, |n| *n = account.get_nonce());
+        smt_state.set_code(addr, Either::Left(code));
+        let key = key_code_length(addr);
+        log::debug!(
+            "setting {:?} code length, the key is {:?}",
+            addr,
+            U256(std::array::from_fn(|i| key.0[i].to_canonical_u64()))
+        );
+    }
+}
diff --git a/evm_arithmetization/src/cpu/cpu_stark.rs b/evm_arithmetization/src/cpu/cpu_stark.rs
index a0dd45e1e..77aad7f55 100644
--- a/evm_arithmetization/src/cpu/cpu_stark.rs
+++ b/evm_arithmetization/src/cpu/cpu_stark.rs
@@ -498,7 +498,10 @@ pub(crate) fn ctl_poseidon_general_input<F: Field>() -> TableWithColumns<F> {
     let len = Column::single(COL_MAP.mem_channels[1].value[0]);
 
     let num_channels = F::from_canonical_usize(NUM_CHANNELS);
-    let timestamp = Column::linear_combination([(COL_MAP.clock, num_channels)]);
+    let timestamp = Column::linear_combination_with_constant(
+        [(COL_MAP.clock, num_channels)],
+        F::ONE - num_channels,
+    );
 
     TableWithColumns::new(
         *Table::Cpu,
@@ -539,7 +542,10 @@ pub(crate) fn ctl_poseidon_general_output<F: Field>() -> TableWithColumns<F> {
     let mut columns = Vec::new();
     columns.extend(Column::singles_next_row(COL_MAP.mem_channels[0].value));
     let num_channels = F::from_canonical_usize(NUM_CHANNELS);
-    columns.push(Column::linear_combination([(COL_MAP.clock, num_channels)]));
+    columns.push(Column::linear_combination_with_constant(
+        [(COL_MAP.clock, num_channels)],
+        F::ONE - num_channels,
+    ));
     TableWithColumns::new(*Table::Cpu, columns, ctl_poseidon_general_filter())
 }
 
diff --git a/evm_arithmetization/src/cpu/kernel/aggregator.rs b/evm_arithmetization/src/cpu/kernel/aggregator.rs
index 9ba350242..984f583fe 100644
--- a/evm_arithmetization/src/cpu/kernel/aggregator.rs
+++ b/evm_arithmetization/src/cpu/kernel/aggregator.rs
@@ -10,8 +10,10 @@ use crate::cpu::kernel::constants::evm_constants;
 use crate::cpu::kernel::parser::parse;
 
 pub const NUMBER_KERNEL_FILES: usize = if cfg!(feature = "eth_mainnet") {
-    157
-} else if cfg!(feature = "cdk_erigon") || cfg!(feature = "polygon_pos") {
+    158
+} else if cfg!(feature = "cdk_erigon") {
+    159
+} else if cfg!(feature = "polygon_pos") {
     154
 } else {
     // unreachable
@@ -21,6 +23,7 @@ pub const NUMBER_KERNEL_FILES: usize = if cfg!(feature = "eth_mainnet") {
 pub static KERNEL_FILES: [&str; NUMBER_KERNEL_FILES] = [
     "global jumped_to_0: PANIC",
     "global jumped_to_1: PANIC",
+    #[cfg(feature = "eth_mainnet")]
     include_str!("asm/beacon_roots.asm"),
     include_str!("asm/bignum/add.asm"),
     include_str!("asm/bignum/addmul.asm"),
@@ -36,7 +39,10 @@ pub static KERNEL_FILES: [&str; NUMBER_KERNEL_FILES] = [
     include_str!("asm/core/call_gas.asm"),
     include_str!("asm/core/create.asm"),
     include_str!("asm/core/create_addresses.asm"),
+    #[cfg(not(feature = "cdk_erigon"))]
     include_str!("asm/core/create_contract_account.asm"),
+    #[cfg(feature = "cdk_erigon")]
+    include_str!("asm/core/create_type2_contract_account.asm"),
     include_str!("asm/core/exception.asm"),
     include_str!("asm/core/create_receipt.asm"),
     include_str!("asm/core/gas.asm"),
@@ -47,7 +53,10 @@ pub static KERNEL_FILES: [&str; NUMBER_KERNEL_FILES] = [
     include_str!("asm/core/process_txn.asm"),
     include_str!("asm/core/syscall.asm"),
     include_str!("asm/core/terminate.asm"),
+    #[cfg(not(feature = "cdk_erigon"))]
     include_str!("asm/core/transfer.asm"),
+    #[cfg(feature = "cdk_erigon")]
+    include_str!("asm/core/transfer_cdk_erigon.asm"),
     include_str!("asm/core/util.asm"),
     include_str!("asm/core/access_lists.asm"),
     include_str!("asm/core/log.asm"),
@@ -120,6 +129,20 @@ pub static KERNEL_FILES: [&str; NUMBER_KERNEL_FILES] = [
     include_str!("asm/hash/sha2/temp_words.asm"),
     include_str!("asm/hash/sha2/write_length.asm"),
     include_str!("asm/main.asm"),
+    #[cfg(not(feature = "cdk_erigon"))]
+    include_str!("asm/linked_list/accounts_linked_list.asm"),
+    #[cfg(not(feature = "cdk_erigon"))]
+    include_str!("asm/linked_list/storage_linked_list.asm"),
+    #[cfg(not(feature = "cdk_erigon"))]
+    include_str!("asm/linked_list/final_tries.asm"),
+    #[cfg(not(feature = "cdk_erigon"))]
+    include_str!("asm/linked_list/initial_tries.asm"),
+    #[cfg(feature = "cdk_erigon")]
+    include_str!("asm/linked_list/type2/state_linked_list.asm"),
+    #[cfg(feature = "cdk_erigon")]
+    include_str!("asm/linked_list/type2/final_tries.asm"),
+    #[cfg(feature = "cdk_erigon")]
+    include_str!("asm/linked_list/type2/initial_tries.asm"),
     include_str!("asm/memory/core.asm"),
     include_str!("asm/memory/memcpy.asm"),
     include_str!("asm/memory/memset.asm"),
@@ -139,9 +162,6 @@ pub static KERNEL_FILES: [&str; NUMBER_KERNEL_FILES] = [
     include_str!("asm/mpt/insert/insert_extension.asm"),
     include_str!("asm/mpt/insert/insert_leaf.asm"),
     include_str!("asm/mpt/insert/insert_trie_specific.asm"),
-    include_str!("asm/mpt/linked_list/linked_list.asm"),
-    include_str!("asm/mpt/linked_list/final_tries.asm"),
-    include_str!("asm/mpt/linked_list/initial_tries.asm"),
     include_str!("asm/mpt/read.asm"),
     include_str!("asm/mpt/storage/storage_read.asm"),
     include_str!("asm/mpt/storage/storage_write.asm"),
@@ -155,6 +175,18 @@ pub static KERNEL_FILES: [&str; NUMBER_KERNEL_FILES] = [
     include_str!("asm/rlp/read_to_memory.asm"),
     include_str!("asm/shift.asm"),
     include_str!("asm/signed.asm"),
+    #[cfg(feature = "cdk_erigon")]
+    include_str!("asm/smt/hash.asm"),
+    #[cfg(feature = "cdk_erigon")]
+    include_str!("asm/smt/insert.asm"),
+    #[cfg(feature = "cdk_erigon")]
+    include_str!("asm/smt/keys.asm"),
+    #[cfg(feature = "cdk_erigon")]
+    include_str!("asm/smt/utils.asm"),
+    #[cfg(feature = "cdk_erigon")]
+    include_str!("asm/smt/delete.asm"),
+    #[cfg(feature = "cdk_erigon")]
+    include_str!("asm/smt/read.asm"),
     include_str!("asm/journal/journal.asm"),
     include_str!("asm/journal/account_loaded.asm"),
     include_str!("asm/journal/account_destroyed.asm"),
diff --git a/evm_arithmetization/src/cpu/kernel/asm/account_code.asm b/evm_arithmetization/src/cpu/kernel/asm/account_code.asm
index 62b5b968b..8e2872de6 100644
--- a/evm_arithmetization/src/cpu/kernel/asm/account_code.asm
+++ b/evm_arithmetization/src/cpu/kernel/asm/account_code.asm
@@ -22,19 +22,30 @@ extcodehash_dead:
     %stack (address, kexit_info) -> (kexit_info, 0)
     EXIT_KERNEL
 
+#[cfg(not(feature = cdk_erigon))]
+{
+global extcodehash:
+        // stack: address, retdest
+        %mpt_read_state_trie
+        // stack: account_ptr, retdest
+        DUP1 ISZERO %jumpi(retzero)
+        %add_const(3)
+        // stack: codehash_ptr, retdest
+        %mload_trie_data
+        // stack: codehash, retdest
+        SWAP1 JUMP
+    retzero:
+        %stack (account_ptr, retdest) -> (retdest, 0)
+        JUMP
+}
+#[cfg(feature = cdk_erigon)]
+{
 global extcodehash:
     // stack: address, retdest
-    %mpt_read_state_trie
-    // stack: account_ptr, retdest
-    DUP1 ISZERO %jumpi(retzero)
-    %add_const(3)
-    // stack: codehash_ptr, retdest
-    %mload_trie_data
+    %read_code
     // stack: codehash, retdest
     SWAP1 JUMP
-retzero:
-    %stack (account_ptr, retdest) -> (retdest, 0)
-    JUMP
+}
 
 %macro extcodehash
     %stack (address) -> (address, %%after)
@@ -44,7 +55,14 @@ retzero:
 
 %macro ext_code_empty
     %extcodehash
-    %eq_const(@EMPTY_STRING_HASH)
+    #[cfg(not(feature = cdk_erigon))]
+    {
+        %eq_const(@EMPTY_STRING_KECCAK_HASH)
+    }
+    #[cfg(feature = cdk_erigon)]
+    {
+        %eq_const(@EMPTY_STRING_POSEIDON_HASH)
+    }
 %endmacro
 
 %macro extcodesize
@@ -100,6 +118,8 @@ load_code_ctd:
     DUP1 ISZERO %jumpi(load_code_non_existent_account)
     // Load the code non-deterministically in memory and return the length.
     PROVER_INPUT(account_code)
+#[cfg(not(feature = cdk_erigon))]
+{
     %stack (code_size, codehash, ctx, retdest) -> (ctx, code_size, codehash, retdest, code_size)
     // Check that the hash of the loaded code equals `codehash`.
     // ctx == DST, as SEGMENT_CODE == offset == 0.
@@ -108,6 +128,11 @@ load_code_ctd:
     %assert_eq
     // stack: retdest, code_size
     JUMP
+}
+#[cfg(feature = cdk_erigon)]
+{
+    %jump(poseidon_hash_code)
+}
 
 load_code_non_existent_account:
     // Write 0 at address 0 for soundness: SEGMENT_CODE == 0, hence ctx == addr.
@@ -138,3 +163,96 @@ load_code_padded_ctd:
     MSTORE_GENERAL
     // stack: retdest, code_size
     JUMP
+
+#[cfg(feature = cdk_erigon)]
+{
+    global poseidon_hash_code:
+    // stack: padded_code_size, codehash, ctx, retdest
+    // %stack (padded_code_size, codehash, ctx) -> (0, 0, padded_code_size, ctx, codehash)
+    %stack (padded_code_size, codehash, ctx) -> (ctx, padded_code_size, codehash, padded_code_size, ctx)
+    POSEIDON_GENERAL
+    %assert_eq
+    // stack: padded_code_size, ctx, retdest
+    %decrement
+    remove_padding_loop:
+        // stack: offset, ctx, retdest
+        DUP2 DUP2 ADD DUP1 MLOAD_GENERAL
+        // stack: code[offset], offset+ctx, offset, ctx, retdest
+        SWAP1 PUSH 0 MSTORE_GENERAL
+        // stack: code[offset], offset, ctx, retdest
+        %and_const(1) %jumpi(remove_padding_after)
+        // stack: offset, ctx, retdest
+        %decrement %jump(remove_padding_loop)
+
+    remove_padding_after:
+        %stack (offset, ctx, retdest) -> (retdest, offset)
+        JUMP
+
+    // Convenience macro to call poseidon_hash_code_unpadded and return where we left off.
+    %macro poseidon_hash_code_unpadded
+        %stack (addr, len) -> (addr, len, %%after)
+        %jump(poseidon_hash_code_unpadded)
+    %%after:
+    %endmacro
+
+    /// Applies the padding rule to the code located at the provided address before hashing it.
+    /// Memory cells after the last code byte will be overwritten.
+    global poseidon_hash_code_unpadded:
+        // stack: addr, len, retdest
+        DUP2 ISZERO %jumpi(poseidon_empty_code)
+        DUP2 DUP2 ADD
+        // stack: padding_addr, addr, len, retdest
+
+        // write 1 after the last code byte
+        DUP1 PUSH 1 MSTORE_GENERAL
+        // stack: padding_addr, addr, len, retdest
+        %increment
+        // stack: padding_addr, addr, len, retdest
+
+        // Pad with 0s until the length is a multiple of 56
+        PUSH 56
+        DUP4 %increment
+        MOD
+        DUP1 %jumpi(non_zero_padding)
+        %jump(padd)
+non_zero_padding:
+        // curr_len mod 56, padding_addr, addr, len, retdest
+        PUSH 56 SUB
+padd:
+        // stack: padding_len, padding_addr, addr, len, retdest
+        SWAP3 DUP4
+        // stack: padding_len, len, padding_addr, addr, padding_len, retdest
+        ADD
+        // stack: last_byte_offset, padding_addr, addr, padding_len, retdest
+        global debug_padding_len:
+        %stack (last_byte_offset, padding_addr, addr, padding_len)
+            -> (padding_addr, padding_len, after_padding, addr, last_byte_offset)
+        %jump(memset)
+    after_padding:
+        // stack: addr, last_byte_offset, retdest
+
+        // Xor the last element with 0x80
+        PUSH 1 DUP3 ADD
+        // stack: total_code_len, addr, last_byte_offset, retdest
+        SWAP2
+        // stack: last_byte_offset, addr, total_code_len, retdest
+        DUP2 ADD
+        // stack: last_byte_addr, addr, total_code_len, retdest
+        DUP1 MLOAD_GENERAL
+        // stack: last_byte, last_byte_addr, addr, total_code_len, retdest
+        PUSH 0x80 ADD
+        // stack: last_byte_updated, last_byte_addr, addr, total_code_len, retdest
+        MSTORE_GENERAL
+        // stack: addr, total_code_len, retdest
+
+        POSEIDON_GENERAL
+        // stack: codehash, retdest
+        SWAP1
+        JUMP
+
+    global poseidon_empty_code:
+        // stack: addr, len, retdest
+        %stack (addr, len, retdest) -> (retdest, @EMPTY_STRING_POSEIDON_HASH)
+        JUMP
+
+}
diff --git a/evm_arithmetization/src/cpu/kernel/asm/balance.asm b/evm_arithmetization/src/cpu/kernel/asm/balance.asm
index d39f66063..9d5484ce4 100644
--- a/evm_arithmetization/src/cpu/kernel/asm/balance.asm
+++ b/evm_arithmetization/src/cpu/kernel/asm/balance.asm
@@ -27,19 +27,10 @@ global sys_balance:
 
 global balance:
     // stack: address, retdest
-    %mpt_read_state_trie
-    // stack: account_ptr, retdest
-    DUP1 ISZERO %jumpi(retzero) // If the account pointer is null, return 0.
-    %add_const(1)
-    // stack: balance_ptr, retdest
-    %mload_trie_data
+    %read_balance
     // stack: balance, retdest
     SWAP1 JUMP
 
-retzero:
-    %stack (account_ptr, retdest) -> (retdest, 0)
-    JUMP
-
 global sys_selfbalance:
     // stack: kexit_info
     %charge_gas_const(@GAS_LOW)
diff --git a/evm_arithmetization/src/cpu/kernel/asm/beacon_roots.asm b/evm_arithmetization/src/cpu/kernel/asm/beacon_roots.asm
index 265d61b90..24d3b173b 100644
--- a/evm_arithmetization/src/cpu/kernel/asm/beacon_roots.asm
+++ b/evm_arithmetization/src/cpu/kernel/asm/beacon_roots.asm
@@ -15,47 +15,47 @@ global set_beacon_root:
     // stack: timestamp, 8191, timestamp, retdest
     MOD
     // stack: timestamp_idx, timestamp, retdest
-    %slot_to_storage_key
-    // stack: timestamp_slot_key, timestamp, retdest
     PUSH @BEACON_ROOTS_CONTRACT_STATE_KEY
     %parent_beacon_block_root
-    // stack: calldata, state_key, timestamp_slot_key, timestamp, retdest
+    // stack: calldata, state_key, timestamp_idx, timestamp, retdest
     PUSH @HISTORY_BUFFER_LENGTH
     DUP5
     MOD
-    // stack: timestamp_idx, calldata, state_key, timestamp_slot_key, timestamp, retdest
+    // stack: timestamp_idx, calldata, state_key, timestamp_idx, timestamp, retdest
     %add_const(@HISTORY_BUFFER_LENGTH)
-    // stack: root_idx, calldata, state_key, timestamp_slot_key, timestamp, retdest
-    %slot_to_storage_key
-    // stack: root_slot_key, calldata, state_key, timestamp_slot_key, timestamp, retdest
+    // stack: root_idx, calldata, state_key, timestamp_idx, timestamp, retdest
     DUP3
-    // stack: state_key, root_slot_key, calldata, state_key, timestamp_slot_key, timestamp, retdest
+    // stack: state_key, root_idx, calldata, state_key, timestamp_idx, timestamp, retdest
     DUP3 ISZERO %jumpi(delete_root_idx_slot)
-    // stack: state_key, root_slot_key, calldata, state_key, timestamp_slot_key, timestamp, retdest
-    %insert_slot_with_value_from_keys
-    // stack: state_key, timestamp_slot_key, timestamp, retdest
-    %insert_slot_with_value_from_keys
+    // stack: state_key, root_idx, calldata, state_key, timestamp_idx, timestamp, 
+global debug_inserting_first_slot:
+    %insert_slot_from_addr_key
+    // stack: state_key, timestamp_idx, timestamp, retdest
+global debug_inserting_second_slot:
+    %insert_slot_from_addr_key
     // stack: retdest
     JUMP
 
+global debug_delete_root_idx_slot:
 delete_root_idx_slot:
-    // stack: state_key, root_slot_key, 0, state_key, timestamp_slot_key, timestamp, retdest
-    DUP3 DUP3 DUP3
-    %search_slot
-    // stack: slot_exists, state_key, root_slot_key, 0, state_key, timestamp_slot_key, timestamp, retdest
+    // stack: state_key, root_idx, calldata, state_key, timestamp_idx, timestamp, retdest
+    DUP2 DUP2
+    %search_slot_from_addr_key
+    // stack: slot_exists, state_key, root_slot_idx, 0, state_key, timestamp_idx, timestamp, retdest
     %jumpi(remove_root_idx_slot)
-    // stack: state_key, root_slot_key, 0, state_key, timestamp_slot_key, timestamp, retdest
+    // stack: state_key, root_idx, 0, state_key, timestamp_idx, timestamp, retdest
     %pop3
-    // stack: state_key, timestamp_slot_key, timestamp, retdest
-    %insert_slot_with_value_from_keys
+    // stack: state_key, timestamp_idx, timestamp, retdest
+global debug_inserting_timestamp_slot:
+    %insert_slot_from_addr_key
     // stack: retdest
     JUMP
 
 remove_root_idx_slot:
-    // stack: state_key, root_slot_key, 0, state_key, timestamp_slot_key, timestamp, retdest
-    %stack(state_key, storage_key, zero) -> (storage_key, state_key)
-    %remove_slot
-    // stack: state_key, timestamp_slot_key, timestamp, retdest
-    %insert_slot_with_value_from_keys
+    // stack: state_key, root_slot_idx, 0, state_key, timestamp_slot_idx, timestamp, retdest
+    %remove_slot_from_addr_key
+    POP
+    // stack: state_key, timestamp_slot_idx, timestamp, retdest
+    %insert_slot_from_addr_key
     // stack: retdest
     JUMP
diff --git a/evm_arithmetization/src/cpu/kernel/asm/cdk_pre_execution.asm b/evm_arithmetization/src/cpu/kernel/asm/cdk_pre_execution.asm
index bc1145d63..5f9f25959 100644
--- a/evm_arithmetization/src/cpu/kernel/asm/cdk_pre_execution.asm
+++ b/evm_arithmetization/src/cpu/kernel/asm/cdk_pre_execution.asm
@@ -19,14 +19,14 @@ global update_scalable_block_number:
     // stack: last_block_slot, block_number, retdest
     %write_scalable_storage
     // stack: retdest
-
     // Check timestamp
-    PUSH @ADDRESS_SCALABLE_L2_STATE_KEY
     PUSH @TIMESTAMP_STORAGE_POS
-    %read_storage_linked_list_w_state_key
+    PUSH @ADDRESS_SCALABLE_L2
+    %read_slot_from_addr_key
     // stack: old_timestamp, retdest
     %timestamp
-    GT %jumpi(update_scalable_timestamp)
+    GT 
+    %jumpi(update_scalable_timestamp)
 
 global update_scalable_prev_block_root_hash:
     // stack: retdest
@@ -73,11 +73,9 @@ global update_scalable_l1blockhash:
     // stack: addr, len, l1blockhash, retdest
     KECCAK_GENERAL
     // stack: slot, l1blockhash, retdest
-    %slot_to_storage_key
-    // stack: storage_key, l1blockhash, retdest
     PUSH @GLOBAL_EXIT_ROOT_MANAGER_L2_STATE_KEY
-    // stack: state_key, storage_key, l1blockhash, retdest
-    %insert_slot_with_value_from_keys
+    // stack: state_key, slot, l1blockhash, retdest
+    %insert_slot_from_addr_key
     // stack: retdest
     JUMP
 
@@ -98,23 +96,21 @@ global create_scalable_l2_account:
     // stack: (empty)
     PUSH update_scalable_block_number
     // stack: retdest
-    %get_trie_data_size // pointer to new account we're about to create
-    // stack: new_account_ptr, retdest
-    PUSH 0 %append_to_trie_data // nonce
-    PUSH 0 %append_to_trie_data // balance
-    PUSH 0 %append_to_trie_data // storage root pointer
-    PUSH @EMPTY_STRING_HASH %append_to_trie_data // code hash
-    // stack: new_account_ptr, retdest
-    PUSH @ADDRESS_SCALABLE_L2_STATE_KEY
-    // stack: key, new_account_ptr, retdest
-    %jump(mpt_insert_state_trie)
+    // Since nonce, balance and code length are 0 we only need to set
+    // the code hash 
+    
+    // stack: retdest
+    PUSH 0
+    PUSH @ADDRESS_SCALABLE_L2
+    %set_code // code hash
+
+    // stack: retdest
+    JUMP
 
 %macro write_scalable_storage
     // stack: slot, value
-    %slot_to_storage_key
-    // stack: storage_key, value
-    PUSH @ADDRESS_SCALABLE_L2_STATE_KEY
-    // stack: state_key, storage_key, value
-    %insert_slot_with_value_from_keys
+    PUSH @ADDRESS_SCALABLE_L2
+    // stack: state_key, slot, value
+    %insert_slot_from_addr_key
     // stack: (empty)
 %endmacro
diff --git a/evm_arithmetization/src/cpu/kernel/asm/core/create.asm b/evm_arithmetization/src/cpu/kernel/asm/core/create.asm
index 1c8e57ee3..fb0594d1a 100644
--- a/evm_arithmetization/src/cpu/kernel/asm/core/create.asm
+++ b/evm_arithmetization/src/cpu/kernel/asm/core/create.asm
@@ -172,7 +172,14 @@ after_constructor:
     %returndatasize
     PUSH @SEGMENT_RETURNDATA GET_CONTEXT %build_address_no_offset
     // stack: addr, len
-    KECCAK_GENERAL
+    #[cfg(not(feature = cdk_erigon))]
+    {
+        KECCAK_GENERAL
+    }
+    #[cfg(feature = cdk_erigon)]
+    {
+        %poseidon_hash_code_unpadded
+    }
     // stack: codehash, leftover_gas, success, address, kexit_info
     %observe_new_contract
     DUP4
@@ -257,19 +264,48 @@ create_too_deep:
 // Pre stack: addr, codehash, redest
 // Post stack: (empty)
 global set_codehash:
-    // stack: addr, codehash, retdest
-    DUP1 %insert_touched_addresses
-    DUP1 %mpt_read_state_trie
-    // stack: account_ptr, addr, codehash, retdest
-    %add_const(3)
-    // stack: codehash_ptr, addr, codehash, retdest
-    DUP1 %mload_trie_data
-    // stack: prev_codehash, codehash_ptr, addr, codehash, retdest
-    DUP3 %journal_add_code_change // Add the code change to the journal.
-    %stack (codehash_ptr, addr, codehash) -> (codehash_ptr, codehash)
-    %mstore_trie_data
-    // stack: retdest
-    JUMP
+    #[cfg(not(feature = cdk_erigon))]
+    {
+        // stack: addr, codehash, retdest
+        DUP1 %insert_touched_addresses
+        DUP1 %mpt_read_state_trie
+        // stack: account_ptr, addr, codehash, retdest
+        %add_const(3)
+        // stack: codehash_ptr, addr, codehash, retdest
+        DUP1 %mload_trie_data
+        // stack: prev_codehash, codehash_ptr, addr, codehash, retdest
+        DUP3 %journal_add_code_change // Add the code change to the journal.
+        %stack (codehash_ptr, addr, codehash) -> (codehash_ptr, codehash)
+        %mstore_trie_data
+        // stack: retdest
+        JUMP
+    }
+    #[cfg(feature = cdk_erigon)]
+    {
+        // stack: addr, codehash, retdest
+        DUP1 %insert_touched_addresses
+        DUP1 
+        %read_code
+        // stack: prev_codehash, addr, codehash, retdest
+        DUP2
+        %read_code_length
+        %stack (prev_code_length, prev_codehash, addr) -> (addr, prev_codehash, prev_code_length, prev_code_length, addr)
+        %journal_add_code_change // Add the code change to the journal.
+        // stack: prev_code_length, addr, codehash, retdest
+        DUP3 DUP3
+        %set_code
+        // stack: prev_code_length, addr, codehash, retdest
+        %returndatasize 
+        SWAP1 DUP2 SUB
+        // stack: code_length - prev_code_length, code_length, addr, code_hash, retdest
+        %jumpi(code_length_changed)
+        %pop3 JUMP
+    code_length_changed:
+        DUP2
+        %set_code_length
+        // stack: addr, codehash, retdest
+        %pop2 JUMP
+    }
 
 // Check and charge gas cost for initcode size. See EIP-3860.
 // Pre stack: code_size, kexit_info
diff --git a/evm_arithmetization/src/cpu/kernel/asm/core/create_contract_account.asm b/evm_arithmetization/src/cpu/kernel/asm/core/create_contract_account.asm
index a614f9fa8..b9ab42cdb 100644
--- a/evm_arithmetization/src/cpu/kernel/asm/core/create_contract_account.asm
+++ b/evm_arithmetization/src/cpu/kernel/asm/core/create_contract_account.asm
@@ -5,15 +5,13 @@
     // stack: address
     DUP1 %insert_touched_addresses
     DUP1 %append_created_contracts
-    DUP1 %mpt_read_state_trie
-    // stack: existing_account_ptr, address
+    %mpt_read_state_trie
+
     // If the account doesn't exist, there's no need to check its balance or nonce,
     // so we can skip ahead, setting existing_balance = existing_account_ptr = 0.
     DUP1 ISZERO %jumpi(%%add_account)
-
-    // Check that the nonce is 0.
-    // stack: existing_account_ptr, address
-    DUP1 %mload_trie_data // nonce = account[0]
+    
+    DUP1 %mload_trie_data// nonce = account[0]
     // stack: nonce, existing_account_ptr, address
     %jumpi(%%error_collision)
     // stack: existing_account_ptr, address
@@ -21,47 +19,45 @@
     %add_const(3)
     // stack: existing_codehash_ptr, address
     DUP1 %mload_trie_data // codehash = account[3]
-    %eq_const(@EMPTY_STRING_HASH) ISZERO %jumpi(%%error_collision)
+    %eq_const(@EMPTY_STRING_KECCAK_HASH) ISZERO %jumpi(%%error_collision)
     // stack: existing_codehash_ptr, address
     %sub_const(2) %mload_trie_data // balance = account[1]
     %jump(%%do_insert)
 
-%%add_account:
-    // stack: existing_balance, address
-    DUP2 PUSH 1
-    // stack: is_contract, address, existing_balance, address
-    %journal_add_account_created
-%%do_insert:
-    // stack: new_acct_value=existing_balance, address
-    // Write the new account's data to MPT data, and get a pointer to it.
-    %get_trie_data_size
-    // stack: account_ptr, new_acct_value, address
-    PUSH 0 DUP4 %journal_add_nonce_change
-    PUSH 1 %append_to_trie_data // nonce = 1
-    // stack: account_ptr, new_acct_value, address
-    SWAP1 %append_to_trie_data // balance = new_acct_value
-    // stack: account_ptr, address
-    PUSH 0 %append_to_trie_data // storage_root = nil
-    // stack: account_ptr, address
-    PUSH @EMPTY_STRING_HASH %append_to_trie_data // code_hash = keccak('')
-    // stack: account_ptr, address
-    SWAP1
-    // stack: address, account_ptr
-    %addr_to_state_key
-    // stack: state_key, account_ptr
-    %mpt_insert_state_trie
-    // stack: (empty)
-    PUSH 0 // success
-    %jump(%%end)
-
+    %%add_account:
+        // stack: existing_balance, address
+        DUP2 PUSH 1
+        // stack: is_contract, address, existing_balance, address
+        %journal_add_account_created
+    %%do_insert:
+        // stack: new_acct_value=existing_balance, address
+        // Write the new account's data to MPT data, and get a pointer to it.
+        %get_trie_data_size
+        // stack: account_ptr, new_acct_value, address
+        PUSH 0 DUP4 %journal_add_nonce_change
+        PUSH 1 %append_to_trie_data // nonce = 1
+        // stack: account_ptr, new_acct_value, address
+        SWAP1 %append_to_trie_data // balance = new_acct_value
+        // stack: account_ptr, address
+        PUSH 0 %append_to_trie_data // storage_root = nil
+        // stack: account_ptr, address
+        PUSH @EMPTY_STRING_KECCAK_HASH %append_to_trie_data // code_hash = keccak('')
+        // stack: account_ptr, address
+        SWAP1
+        // stack: address, account_ptr
+        %addr_to_state_key
+        // stack: state_key, account_ptr
+        %mpt_insert_state_trie
+        // stack: (empty)
+        PUSH 0 // success
+        %jump(%%end)
 // If the nonce is nonzero or the code is non-empty, that means a contract has already been deployed to this address.
 // (This should be impossible with contract creation transactions or CREATE, but possible with CREATE2.)
 // So we return 1 to indicate an error.
 %%error_collision:
-    %stack (existing_account_ptr, address) -> (1)
-
+            %stack (address) -> (1)
 %%end:
-    // stack: status
+            // stack: status
 %endmacro
 
 %macro append_created_contracts
diff --git a/evm_arithmetization/src/cpu/kernel/asm/core/create_receipt.asm b/evm_arithmetization/src/cpu/kernel/asm/core/create_receipt.asm
index edcd3f329..2c5d24f61 100644
--- a/evm_arithmetization/src/cpu/kernel/asm/core/create_receipt.asm
+++ b/evm_arithmetization/src/cpu/kernel/asm/core/create_receipt.asm
@@ -1,13 +1,13 @@
 // Pre-stack: status, leftover_gas, prev_cum_gas, txn_nb, num_nibbles, retdest
 // Post stack: new_cum_gas, txn_nb
-// A receipt is stored in MPT_TRIE_DATA as:
+// A receipt is stored in TRIE_DATA as:
 // [payload_len, status, cum_gas_used, bloom, logs_payload_len, num_logs, [logs]]
 //
 // In this function, we:
 // - compute cum_gas, 
 // - check if the transaction failed and set number of logs to 0 if it is the case, 
 // - compute the bloom filter,
-// - write the receipt in MPT_TRIE_DATA ,
+// - write the receipt in TRIE_DATA ,
 // - insert a new node in receipt_trie,
 // - set the bloom filter back to 0
 global process_receipt:
@@ -51,7 +51,7 @@ process_receipt_after_bloom:
     %rlp_list_len
     ADD
     // stack: payload_len, status, new_cum_gas, txn_nb, new_cum_gas, txn_nb, num_nibbles, retdest
-    // Now we can write the receipt in MPT_TRIE_DATA.
+    // Now we can write the receipt in TRIE_DATA.
     %get_trie_data_size
     // stack: receipt_ptr, payload_len, status, new_cum_gas, txn_nb, new_cum_gas, txn_nb, num_nibbles, retdest
     // Write transaction type if necessary.
@@ -103,7 +103,7 @@ process_receipt_after_type:
     DUP1 %append_to_trie_data
     PUSH 0
 
-// Each log is written in MPT_TRIE_DATA as:
+// Each log is written in TRIE_DATA as:
 // [payload_len, address, num_topics, [topics], data_len, [data]].
 process_receipt_logs_loop:
     // stack: i, num_logs, receipt_ptr, txn_nb, new_cum_gas, txn_nb, num_nibbles, retdest
diff --git a/evm_arithmetization/src/cpu/kernel/asm/core/create_type2_contract_account.asm b/evm_arithmetization/src/cpu/kernel/asm/core/create_type2_contract_account.asm
new file mode 100644
index 000000000..73b4b9959
--- /dev/null
+++ b/evm_arithmetization/src/cpu/kernel/asm/core/create_type2_contract_account.asm
@@ -0,0 +1,62 @@
+// Create a smart contract account with the given address and the given endowment value.
+// Pre stack: address
+// Post stack: status
+%macro create_contract_account
+    // stack: address
+    DUP1 %insert_touched_addresses
+    DUP1 %append_created_contracts
+    DUP1 %read_code ISZERO %jumpi(%%add_account)
+    // Check that the nonce is 0.
+    // stack: address
+    DUP1 %nonce
+    // stack: nonce, address
+    %jumpi(%%error_collision)
+    // stack: address
+    // Check that the code is empty.
+    DUP1 %extcodehash
+    %eq_const(@EMPTY_STRING_POSEIDON_HASH) ISZERO %jumpi(%%error_collision)
+    DUP1 %balance
+    %jump(%%do_insert)
+
+    %%add_account:
+        // stack: address
+        DUP1 PUSH 1
+        // stack: is_contract, address, address
+        %journal_add_account_created
+        // stack: address
+        PUSH 0
+    %%do_insert:
+        // stack: new_acct_value, address
+        // Write the new account's data to MPT data, and get a pointer to it.
+        // stack: new_acct_value, address
+        PUSH 0 DUP3 %journal_add_nonce_change
+        %stack (new_acct_value, address) -> (address, 1, new_acct_value, address)
+        %set_nonce // nonce = 1
+        // stack: new_acct_value, address
+        DUP2 %set_balance // balance = new_acct_value
+        %stack (address) -> (address, @EMPTY_STRING_POSEIDON_HASH)
+        %set_code
+        // stack: empty
+        PUSH 0 // success
+        %jump(%%end)
+    
+    // If the nonce is nonzero or the code is non-empty, that means a contract has already been deployed to this address.
+    // (This should be impossible with contract creation transactions or CREATE, but possible with CREATE2.)
+    // So we return 1 to indicate an error.
+    %%error_collision:
+        %stack (address) -> (1)
+    %%end:
+    // stack: status
+%endmacro
+
+%macro append_created_contracts
+    // stack: address
+    %mload_global_metadata(@GLOBAL_METADATA_CREATED_CONTRACTS_LEN)
+    // stack: nb_created_contracts, address
+    SWAP1 DUP2
+    // stack: nb_created_contracts, address, nb_created_contracts
+    %mstore_kernel(@SEGMENT_CREATED_CONTRACTS)
+    // stack: nb_created_contracts
+    %increment
+    %mstore_global_metadata(@GLOBAL_METADATA_CREATED_CONTRACTS_LEN)
+%endmacro
diff --git a/evm_arithmetization/src/cpu/kernel/asm/core/nonce.asm b/evm_arithmetization/src/cpu/kernel/asm/core/nonce.asm
index 48486be9e..62b3d2c90 100644
--- a/evm_arithmetization/src/cpu/kernel/asm/core/nonce.asm
+++ b/evm_arithmetization/src/cpu/kernel/asm/core/nonce.asm
@@ -3,12 +3,7 @@
 // Post stack: (empty)
 global nonce:
     // stack: address, retdest
-    %mpt_read_state_trie
-    // stack: account_ptr, retdest
-    // The nonce is the first account field, so we deref the account pointer itself.
-    // Note: We don't need to handle account_ptr=0, as trie_data[0] = 0,
-    // so the deref will give 0 (the default nonce) as desired.
-    %mload_trie_data
+    %read_nonce
     // stack: nonce, retdest
     SWAP1 JUMP
 
@@ -21,25 +16,58 @@ global nonce:
 
 // Increment the given account's nonce. Assumes the account already exists; panics otherwise.
 global increment_nonce:
-    // stack: address, retdest
-    DUP1
-    %mpt_read_state_trie
-    // stack: account_ptr, address, retdest
-    DUP1 ISZERO %jumpi(increment_nonce_no_such_account)
-    // stack: nonce_ptr, address, retdest
-    DUP1 %mload_trie_data
-    // stack: nonce, nonce_ptr, address, retdest
-    DUP1 DUP4 %journal_add_nonce_change
-    // stack: nonce, nonce_ptr, address, retdest
-    %increment
-    SWAP1
-    // stack: nonce_ptr, nonce', address, retdest
-    %mstore_trie_data
-    // stack: address, retdest
-    POP
-    JUMP
-global increment_nonce_no_such_account:
-    PANIC
+    #[cfg(not(feature = cdk_erigon))]
+    {
+        // stack: address, retdest
+        DUP1
+        %mpt_read_state_trie
+        // stack: account_ptr, address, retdest
+        DUP1 ISZERO %jumpi(increment_nonce_no_such_account)
+        // stack: nonce_ptr, address, retdest
+        DUP1 %mload_trie_data
+        // stack: nonce, nonce_ptr, address, retdest
+        DUP1 DUP4 %journal_add_nonce_change
+        // stack: nonce, nonce_ptr, address, retdest
+        %increment
+        SWAP1
+        // stack: nonce_ptr, nonce', address, retdest
+        %mstore_trie_data
+        // stack: address, retdest
+        POP
+        JUMP
+    global increment_nonce_no_such_account:
+        PANIC
+    }
+    #[cfg(feature = cdk_erigon)]
+    {
+        // stack: address, retdest
+        DUP1
+        %read_nonce
+        // stack: nonce, address, retdest
+        DUP1 ISZERO %jumpi(create_nonce)
+        // stack: nonce, address, retdest
+        // stack: nonce, address, retdest
+        DUP1 DUP3 %journal_add_nonce_change
+        // stack: nonce, address, retdest
+        %increment
+        SWAP1
+        // stack: address, nonce', retdest
+        %set_nonce
+        // stack: retdest
+        JUMP
+
+        create_nonce:
+            // stack: nonce, address, retdest
+            POP
+            // stack: address, retdest
+            PUSH 0 DUP2 %journal_add_nonce_change
+            // stack: address, retdest
+            PUSH 1
+            SWAP1
+            %set_nonce
+            JUMP
+    }
+
 
 // Convenience macro to call increment_nonce and return where we left off.
 %macro increment_nonce
diff --git a/evm_arithmetization/src/cpu/kernel/asm/core/precompiles/main.asm b/evm_arithmetization/src/cpu/kernel/asm/core/precompiles/main.asm
index d29bff2e1..1556de093 100644
--- a/evm_arithmetization/src/cpu/kernel/asm/core/precompiles/main.asm
+++ b/evm_arithmetization/src/cpu/kernel/asm/core/precompiles/main.asm
@@ -25,7 +25,8 @@ global handle_precompiles:
     }
     #[cfg(not(feature = eth_mainnet))]
     {
-        %eq_const(@BLAKE2_F) %jumpi(precompile_blake2_f)
+        DUP1 %eq_const(@BLAKE2_F) %jumpi(precompile_blake2_f)
+        POP
     }
     // TODO: Add support of EIP-7712 for Polygon Pos, https://github.com/0xPolygonZero/zk_evm/issues/265
     // stack: retdest
diff --git a/evm_arithmetization/src/cpu/kernel/asm/core/process_txn.asm b/evm_arithmetization/src/cpu/kernel/asm/core/process_txn.asm
index 28252d012..d8f39df5d 100644
--- a/evm_arithmetization/src/cpu/kernel/asm/core/process_txn.asm
+++ b/evm_arithmetization/src/cpu/kernel/asm/core/process_txn.asm
@@ -36,7 +36,8 @@ global process_normalized_txn:
     // stack: sender, retdest
 
     // Assert sender has no code.
-    DUP1 %ext_code_empty %assert_nonzero(invalid_txn_1)
+    DUP1 %ext_code_empty
+    %assert_nonzero(invalid_txn_1)
     // stack: sender, retdest
 
     // Assert sender balance >= gas_limit * gas_price + value.
@@ -212,8 +213,15 @@ process_contract_creation_txn_after_ef_check:
     PUSH @SEGMENT_RETURNDATA
     GET_CONTEXT
     %build_address_no_offset
-    // stack: addr, len
-    KECCAK_GENERAL
+    // stack: addr, len, leftover_gas, new_ctx, address, retdest, success
+    #[cfg(feature = cdk_erigon)]
+    {
+        %poseidon_hash_code_unpadded
+    }
+    #[cfg(not(feature = cdk_erigon))]
+    {
+        KECCAK_GENERAL
+    }
     // stack: codehash, leftover_gas, new_ctx, address, retdest, success
     %observe_new_contract
     DUP4
diff --git a/evm_arithmetization/src/cpu/kernel/asm/core/selfdestruct_list.asm b/evm_arithmetization/src/cpu/kernel/asm/core/selfdestruct_list.asm
index 05e158c34..bf70ad447 100644
--- a/evm_arithmetization/src/cpu/kernel/asm/core/selfdestruct_list.asm
+++ b/evm_arithmetization/src/cpu/kernel/asm/core/selfdestruct_list.asm
@@ -72,7 +72,8 @@ bingo:
     %increment %jump(delete_all_selfdestructed_addresses_loop)
 delete_all_selfdestructed_addresses_done:
     // stack: i, len, retdest
-    %pop2 JUMP
+    %pop2 
+    JUMP
 
 %macro delete_all_selfdestructed_addresses
     %stack () -> (%%after)
diff --git a/evm_arithmetization/src/cpu/kernel/asm/core/terminate.asm b/evm_arithmetization/src/cpu/kernel/asm/core/terminate.asm
index 2e3482ea3..0fe6fe418 100644
--- a/evm_arithmetization/src/cpu/kernel/asm/core/terminate.asm
+++ b/evm_arithmetization/src/cpu/kernel/asm/core/terminate.asm
@@ -86,16 +86,27 @@ global sys_selfdestruct:
     %stack (kexit_info, balance, address, recipient) -> (balance, address, recipient, kexit_info)
 
     // Set the balance of the address to 0.
-    // stack: balance, address, recipient, kexit_info
-    PUSH 0
-    // stack: 0, balance, address, recipient, kexit_info
-    DUP3 %mpt_read_state_trie
-    // stack: account_ptr, 0, balance, address, recipient, kexit_info
-    %add_const(1)
-    // stack: balance_ptr, 0, balance, address, recipient, kexit_info
-    %mstore_trie_data
-
-
+    #[cfg(not(feature = cdk_erigon))]
+    {
+        // stack: balance, address, recipient, kexit_info
+        PUSH 0
+        // stack: 0, balance, address, recipient, kexit_info
+        DUP3 %mpt_read_state_trie
+        // stack: account_ptr, 0, balance, address, recipient, kexit_info
+        %add_const(1)
+        // stack: balance_ptr, 0, balance, address, recipient, kexit_info
+        %mstore_trie_data
+    }
+    #[cfg(feature = cdk_erigon)]
+    {
+        // Set the balance of the address to 0.
+        // stack: balance, address, recipient, kexit_info
+        DUP1 ISZERO %jumpi(selfdestruct_balance_is_zero)
+        DUP2 %remove_balance
+        // stack: balance, address, recipient, kexit_info
+    }
+
+selfdestruct_balance_is_zero:
     // EIP-6780: insert address into the selfdestruct set only if contract has been created
     // during the current transaction.
     // stack: balance, address, recipient, kexit_info
diff --git a/evm_arithmetization/src/cpu/kernel/asm/core/touched_addresses.asm b/evm_arithmetization/src/cpu/kernel/asm/core/touched_addresses.asm
index a8e926e77..b1e72bbec 100644
--- a/evm_arithmetization/src/cpu/kernel/asm/core/touched_addresses.asm
+++ b/evm_arithmetization/src/cpu/kernel/asm/core/touched_addresses.asm
@@ -92,7 +92,8 @@ delete_all_touched_addresses_loop:
     // stack: i, len, retdest
     DUP1 MLOAD_GENERAL
     // stack: loaded_addr, i, len, retdest
-    DUP1 %is_empty %jumpi(bingo)
+    DUP1
+    %is_empty %jumpi(bingo)
     // stack: loaded_addr, i, len, retdest
     POP %increment %jump(delete_all_touched_addresses_loop)
 bingo:
@@ -101,7 +102,8 @@ bingo:
     %increment %jump(delete_all_touched_addresses_loop)
 delete_all_touched_addresses_done:
     // stack: i, len, retdest
-    %pop2 JUMP
+    %pop2 
+    JUMP
 
 %macro delete_all_touched_addresses
     %stack () -> (%%after)
diff --git a/evm_arithmetization/src/cpu/kernel/asm/core/transfer.asm b/evm_arithmetization/src/cpu/kernel/asm/core/transfer.asm
index b21828f5e..bca8ce988 100644
--- a/evm_arithmetization/src/cpu/kernel/asm/core/transfer.asm
+++ b/evm_arithmetization/src/cpu/kernel/asm/core/transfer.asm
@@ -98,7 +98,7 @@ global add_eth_new_account:
     %append_to_trie_data // balance
     // stack: addr, new_account_ptr, retdest
     PUSH 0 %append_to_trie_data // storage root pointer
-    PUSH @EMPTY_STRING_HASH %append_to_trie_data // code hash
+    PUSH @EMPTY_STRING_KECCAK_HASH %append_to_trie_data // code hash
     // stack: addr, new_account_ptr, retdest
     %addr_to_state_key
     // stack: key, new_account_ptr, retdest
diff --git a/evm_arithmetization/src/cpu/kernel/asm/core/transfer_cdk_erigon.asm b/evm_arithmetization/src/cpu/kernel/asm/core/transfer_cdk_erigon.asm
new file mode 100644
index 000000000..579542096
--- /dev/null
+++ b/evm_arithmetization/src/cpu/kernel/asm/core/transfer_cdk_erigon.asm
@@ -0,0 +1,120 @@
+// Transfers some ETH from one address to another. The amount is given in wei.
+// Pre stack: from, to, amount, retdest
+// Post stack: status (0 indicates success)
+global transfer_eth:
+    // stack: from, to, amount, retdest
+    %stack (from, to, amount, retdest)
+        -> (from, amount, to, amount, retdest)
+    %deduct_eth
+    // stack: deduct_eth_status, to, amount, retdest
+    %jumpi(transfer_eth_failure)
+    // stack: to, amount, retdest
+    %add_eth
+    %stack (retdest) -> (retdest, 0)
+    JUMP
+global transfer_eth_failure:
+    %stack (to, amount, retdest) -> (retdest, 1)
+    JUMP
+
+// Convenience macro to call transfer_eth and return where we left off.
+%macro transfer_eth
+    %stack (from, to, amount) -> (from, to, amount, %%after)
+    %jump(transfer_eth)
+%%after:
+%endmacro
+
+// Returns 0 on success, or 1 if addr has insufficient balance. Panics if addr isn't found in the trie.
+// Pre stack: addr, amount, retdest
+// Post stack: status (0 indicates success)
+global deduct_eth:
+    // stack: addr, amount, retdest
+    DUP1 %insert_touched_addresses
+    DUP2 ISZERO %jumpi(deduct_eth_noop)
+    DUP1 %read_balance
+    // stack: balance, addr, amount, retdest
+    // stack: balance, addr, amount, retdest
+    DUP1 DUP4 GT
+    // stack: amount > balance, balance, addr, amount, retdest
+    %jumpi(deduct_eth_insufficient_balance)
+    // stack: balance, addr, amount, retdest
+    DUP1 DUP4 EQ
+    // stack: amount == balance, balance, addr, amount, retdest
+    %jumpi(deduct_eth_delete_balance)
+    %stack (balance, addr, amount, retdest) -> (balance, amount, addr, retdest, 0)
+    SUB
+    SWAP1
+    // stack: addr, balance - amount, retdest, 0
+    %set_balance
+    // stack: retdest, 0
+    JUMP
+deduct_eth_insufficient_balance:
+    %stack (balance, addr, amount, retdest) -> (retdest, 1)
+    JUMP
+deduct_eth_delete_balance:
+    %stack (balance, addr, amount, retdest) -> (addr, retdest, 0)
+    %remove_balance
+    // stack: retdest, 0
+    JUMP
+deduct_eth_noop:
+    %stack (addr, amount, retdest) -> (retdest, 0)
+    JUMP
+
+// Convenience macro to call deduct_eth and return where we left off.
+%macro deduct_eth
+    %stack (addr, amount) -> (addr, amount, %%after)
+    %jump(deduct_eth)
+%%after:
+%endmacro
+
+// Pre stack: addr, amount, redest
+// Post stack: (empty)
+global add_eth:
+    // stack: addr, amount, retdest
+    DUP1 %insert_touched_addresses
+    DUP2 ISZERO %jumpi(add_eth_noop)
+    // stack: addr, amount, retdest
+    DUP1 %read_code
+    // stack: codehash, addr, amount, retdest
+    ISZERO %jumpi(add_eth_new_account) // If the account is empty, we need to create the account.
+    // stack: addr, amount, retdest
+    %key_balance
+    // stack: key_balance, amount
+    DUP1 %search_key // TODO: replace with read_balance?
+    DUP1 ISZERO %jumpi(add_eth_zero_balance)
+    %stack (balance, key_balance, amount) -> (balance, amount, key_balance)
+    // stack: balance, amount, key_balance, retdest
+    ADD
+    // stack: balance+amount, key_balance, retdest
+    SWAP1 %insert_key
+    JUMP
+add_eth_zero_balance:
+    // stack: balance, key_balance, amount, retdest
+    POP
+    // stack: key_balance, amount, retdest
+    %insert_key // TODO: replace with set_balance?
+    // stack: retdest
+    JUMP
+
+global add_eth_new_account:
+    // stack: addr, amount, retdest
+    DUP1 PUSH 0
+    // stack: is_eoa, addr, amount, retdest
+    %journal_add_account_created
+    // stack: addr, amount, retdest
+    DUP1 %key_code
+    %stack (key_code) -> (key_code, @EMPTY_STRING_POSEIDON_HASH)
+    %insert_key // TODO: replace with set_code?
+    // stack: addr, amount, retdest
+    %set_balance
+    JUMP
+
+add_eth_noop:
+    // stack: addr, amount, retdest
+    %pop2 JUMP
+
+// Convenience macro to call add_eth and return where we left off.
+%macro add_eth
+    %stack (addr, amount) -> (addr, amount, %%after)
+    %jump(add_eth)
+%%after:
+%endmacro
diff --git a/evm_arithmetization/src/cpu/kernel/asm/core/util.asm b/evm_arithmetization/src/cpu/kernel/asm/core/util.asm
index 78864c1ca..ee02a615c 100644
--- a/evm_arithmetization/src/cpu/kernel/asm/core/util.asm
+++ b/evm_arithmetization/src/cpu/kernel/asm/core/util.asm
@@ -57,33 +57,79 @@
 // Returns 1 if the account is non-existent, 0 otherwise.
 %macro is_non_existent
     // stack: addr
-    %mpt_read_state_trie ISZERO
+    #[cfg(not(feature = cdk_erigon))]
+    {
+        %mpt_read_state_trie ISZERO
+    }
+    #[cfg(feature = cdk_erigon)]
+    {
+        %key_code %search_key ISZERO
+    }
 %endmacro
 
 // Returns 1 if the account is empty, 0 otherwise.
-%macro is_empty
-    // stack: addr
-    %mpt_read_state_trie
-    // stack: account_ptr
-    DUP1 ISZERO %jumpi(%%false)
-    // stack: account_ptr
-    DUP1 %mload_trie_data
-    // stack: nonce, account_ptr
-    ISZERO %not_bit %jumpi(%%false)
-    %increment DUP1 %mload_trie_data
-    // stack: balance, balance_ptr
-    ISZERO %not_bit %jumpi(%%false)
-    %add_const(2) %mload_trie_data
-    // stack: code_hash
-    PUSH @EMPTY_STRING_HASH
-    EQ
-    %jump(%%after)
-%%false:
-    // stack: account_ptr
-    POP
-    PUSH 0
-%%after:
-%endmacro
+#[cfg(not(feature = cdk_erigon))]
+{
+    %macro is_empty
+        // stack: addr
+        %mpt_read_state_trie
+        // stack: account_ptr
+        DUP1 ISZERO
+        %jumpi(%%false)
+
+        // stack: account_ptr
+        DUP1 %mload_trie_data
+        // stack: nonce, account_ptr
+        ISZERO %not_bit
+        %jumpi(%%false)
+
+        %increment DUP1 %mload_trie_data
+        // stack: balance, balance_ptr
+        ISZERO %not_bit 
+        %jumpi(%%false)
+
+        %add_const(2) %mload_trie_data
+        // stack: code_hash
+        %eq_const(@EMPTY_STRING_KECCAK_HASH)
+        %jump(%%after)
+
+    %%false:
+        // stack: account_ptr
+        POP
+        PUSH 0
+    %%after:
+    %endmacro
+}
+
+// Returns 1 if the account is empty, 0 otherwise.
+#[cfg(feature = cdk_erigon)]
+{
+    %macro is_empty
+        // stack: addr
+        DUP1 %read_nonce
+        // stack: nonce, addr
+        ISZERO %not_bit
+        %jumpi(%%false)
+
+        // stack: addr
+        DUP1 %read_balance
+        // stack: balance, addr
+        ISZERO %not_bit
+        %jumpi(%%false)
+
+        // stack: addr
+        %read_code
+        // stack: codehash
+        %eq_const(@EMPTY_STRING_POSEIDON_HASH)
+        %jump(%%after)
+
+    %%false:
+        // stack: account_ptr
+        POP
+        PUSH 0
+    %%after:
+    %endmacro
+}
 
 // Returns 1 if the account is dead (i.e., empty or non-existent), 0 otherwise.
 %macro is_dead
diff --git a/evm_arithmetization/src/cpu/kernel/asm/journal/account_destroyed.asm b/evm_arithmetization/src/cpu/kernel/asm/journal/account_destroyed.asm
index d62f3d422..1bcafa20b 100644
--- a/evm_arithmetization/src/cpu/kernel/asm/journal/account_destroyed.asm
+++ b/evm_arithmetization/src/cpu/kernel/asm/journal/account_destroyed.asm
@@ -12,27 +12,47 @@ global revert_account_destroyed:
     PUSH revert_account_destroyed_contd DUP2
     %jump(remove_selfdestruct_list)
 revert_account_destroyed_contd:
-    // stack: address, target, prev_balance, retdest
-    SWAP1
-    // Remove `prev_balance` from `target`'s balance.
-    // stack: target, address, prev_balance, retdest
-    %read_accounts_linked_list
-    // stack: target_payload_ptr, address, prev_balance, retdest
-    DUP1
-    %assert_nonzero
-    %add_const(1)
-    // stack: target_balance_ptr, address, prev_balance, retdest
-    DUP3
-    DUP2 %mload_trie_data
-    // stack: target_balance, prev_balance, target_balance_ptr, address, prev_balance, retdest
-    SUB SWAP1 %mstore_trie_data
-    // Set `address`'s balance to `prev_balance`.
-    // stack: address, prev_balance, retdest
-    %read_accounts_linked_list
-    // stack: account_payload_ptr, prev_balance, retdest
-    DUP1 
-    %assert_nonzero
-    %increment
-    // stack: account_balance_payload_ptr, prev_balance, retdest
-    %mstore_trie_data
-    JUMP
+    #[cfg(not(feature = cdk_erigon))]
+    {
+        // stack: address, target, prev_balance, retdest
+        SWAP1
+        // Remove `prev_balance` from `target`'s balance.
+        // stack: target, address, prev_balance, retdest
+        %read_account_from_addr
+        // stack: target_payload_ptr, address, prev_balance, retdest
+        DUP1
+        %assert_nonzero
+        %add_const(1)
+        // stack: target_balance_ptr, address, prev_balance, retdest
+        DUP3
+        DUP2 %mload_trie_data
+        // stack: target_balance, prev_balance, target_balance_ptr, address, prev_balance, retdest
+        SUB SWAP1 %mstore_trie_data
+        // Set `address`'s balance to `prev_balance`.
+        // stack: address, prev_balance, retdest
+        %read_account_from_addr
+        // stack: account_payload_ptr, prev_balance, retdest
+        DUP1 
+        %assert_nonzero
+        %increment
+        // stack: account_balance_payload_ptr, prev_balance, retdest
+        %mstore_trie_data
+        JUMP
+    }
+    #[cfg(feature = cdk_erigon)]
+    {
+        // stack: address, target, prev_balance, retdest
+        SWAP1
+        // Remove `prev_balance` from `target`'s balance.
+        // stack: target, address, prev_balance, retdest
+        %key_balance DUP1 %search_key
+        // stack: target_balance, target_balance_key, address, prev_balance, retdest
+        %stack (target_balance, target_balance_key, address, prev_balance) -> (target_balance, prev_balance, target_balance_key, address, prev_balance)
+        // stack: target_balance, prev_balance, target_balance_key, address, prev_balance, retdest
+        SUB SWAP1 %insert_key
+        // Set `address`'s balance to `prev_balance`.
+        // stack: address, prev_balance, retdest
+        %set_balance
+        // stack: retdest
+        JUMP
+    }
\ No newline at end of file
diff --git a/evm_arithmetization/src/cpu/kernel/asm/journal/code_change.asm b/evm_arithmetization/src/cpu/kernel/asm/journal/code_change.asm
index 0fc33f9dd..1e8a90615 100644
--- a/evm_arithmetization/src/cpu/kernel/asm/journal/code_change.asm
+++ b/evm_arithmetization/src/cpu/kernel/asm/journal/code_change.asm
@@ -1,20 +1,41 @@
 // struct CodeChange { address, prev_codehash }
 
 %macro journal_add_code_change
-    %journal_add_2(@JOURNAL_ENTRY_CODE_CHANGE)
+    #[cfg(not(feature = cdk_erigon))]
+    {
+        %journal_add_2(@JOURNAL_ENTRY_CODE_CHANGE)
+    }
+    #[cfg(feature = cdk_erigon)]
+    {
+        %journal_add_3(@JOURNAL_ENTRY_CODE_CHANGE)
+    }
 %endmacro
 
 global revert_code_change:
-    // stack: entry_ptr, ptr, retdest
-    POP
-    %journal_load_2
-    // stack: address, prev_codehash, retdest
-    %read_accounts_linked_list
-    // stack: account_ptr, prev_codehash, retdest
-    DUP1 %assert_nonzero
-    // stack: account_ptr, prev_codehash, retdest
-    %add_const(3)
-    // stack: codehash_ptr, prev_codehash, retdest
-    %mstore_trie_data
-    // stack: retdest
-    JUMP
+    #[cfg(not(feature = cdk_erigon))]
+    {
+        // stack: entry_ptr, ptr, retdest
+        POP
+        %journal_load_2
+        // stack: address, prev_codehash, retdest
+        %read_account_from_addr
+        // stack: account_ptr, prev_codehash, retdest
+        DUP1 %assert_nonzero
+        // stack: account_ptr, prev_codehash, retdest
+        %add_const(3)
+        // stack: codehash_ptr, prev_codehash, retdest
+        %mstore_trie_data
+        // stack: retdest
+        JUMP
+    }
+    #[cfg(feature = cdk_erigon)]
+    {
+        // stack: entry_ptr, ptr, retdest
+        POP
+        %journal_load_3
+        %stack (address, prev_codehash, prev_code_length) -> (address, prev_codehash, address, prev_code_length)
+        %set_code
+        %set_code_length
+        // stack: retdest
+        JUMP
+    }
diff --git a/evm_arithmetization/src/cpu/kernel/asm/journal/nonce_change.asm b/evm_arithmetization/src/cpu/kernel/asm/journal/nonce_change.asm
index 0c1198e52..df4af3c7a 100644
--- a/evm_arithmetization/src/cpu/kernel/asm/journal/nonce_change.asm
+++ b/evm_arithmetization/src/cpu/kernel/asm/journal/nonce_change.asm
@@ -9,10 +9,6 @@ global revert_nonce_change:
     POP
     %journal_load_2
     // stack: address, prev_nonce, retdest
-    %read_accounts_linked_list
-    // stack: payload_ptr, prev_nonce, retdest
-    DUP1 %assert_nonzero
-    // stack: nonce_ptr, prev_nonce, retdest
-    %mstore_trie_data
+    %set_nonce
     // stack: retdest
     JUMP
diff --git a/evm_arithmetization/src/cpu/kernel/asm/journal/storage_change.asm b/evm_arithmetization/src/cpu/kernel/asm/journal/storage_change.asm
index 695975c1f..3ab586e36 100644
--- a/evm_arithmetization/src/cpu/kernel/asm/journal/storage_change.asm
+++ b/evm_arithmetization/src/cpu/kernel/asm/journal/storage_change.asm
@@ -11,14 +11,11 @@ global revert_storage_change:
     // stack: address, slot, prev_value, retdest
     DUP3 ISZERO %jumpi(delete)
     // stack: address, slot, prev_value, retdest
-    %insert_slot_with_value
+    %insert_slot
     JUMP
 
 delete:
     // stack: address, slot, prev_value, retdest
-    SWAP2 POP
-    // stack: slot, address, retdest
-    %slot_to_storage_key
-    SWAP1 %addr_to_state_key
-    // stack: addr_key, slot_key, retdest
-    %jump(remove_slot)
+    %remove_slot_from_addr
+    POP
+    JUMP
diff --git a/evm_arithmetization/src/cpu/kernel/asm/linked_list/accounts_linked_list.asm b/evm_arithmetization/src/cpu/kernel/asm/linked_list/accounts_linked_list.asm
new file mode 100644
index 000000000..9ffcdd347
--- /dev/null
+++ b/evm_arithmetization/src/cpu/kernel/asm/linked_list/accounts_linked_list.asm
@@ -0,0 +1,456 @@
+/// The accounts linked list is stored in SEGMENT_ACCOUNTS_LINKED_LIST in the kernel memory (context=0). 
+/// The length of the segment is stored in @GLOBAL_METADATA_ACCOUNTS_LINKED_LIST_NEXT_AVAILABLE.
+/// Searching and inserting is done by guessing the predecessor in the list.
+/// If the address key isn't found in the array, it is inserted 
+/// at the correct location. The linked lists are used to keep track of
+/// inserted, modified and deleted accounts during the execution, so that the 
+/// initial and final MPT state tries can be reconstructed at the end of the execution.
+/// An empty account linked list is written as
+/// [@U256_MAX, _, _, @SEGMENT_ACCOUNTS_LINKED_LIST] in SEGMENT_ACCOUNTS_LINKED_LIST.
+/// Each account is encoded using 4 values:
+/// - 0: The account key
+/// - 1: A ptr to the payload (the account values)
+/// - 2: A ptr to the initial payload.
+/// - 3: A ptr (in segment @SEGMENT_ACCOUNTS_LINKED_LIST) to the next node in the list.
+
+%macro store_initial_accounts
+    PUSH %%after
+    %jump(store_initial_accounts)
+%%after:
+%endmacro
+
+/// Iterates over the initial account linked list and shallow copies
+/// the accounts, storing a pointer to the copied account in the node.
+/// Computes the length of `SEGMENT_ACCOUNTS_LINKED_LIST` and 
+/// stores it in `GLOBAL_METADATA_ACCOUNTS_LINKED_LIST_NEXT_AVAILABLE`.
+/// It also checks that the next node address is current address + 4
+/// and that all keys are strictly increasing.
+/// NOTE: It may be more efficient to check that the next node addres != U256_MAX
+/// (i.e. node was not deleted) and ensure that no node with repeated key
+/// is ever read.
+global store_initial_accounts:
+    // stack: retdest
+    PUSH @ACCOUNTS_LINKED_LISTS_NODE_SIZE
+    PUSH @SEGMENT_ACCOUNTS_LINKED_LIST
+    ADD
+    // stack: cur_len, retdest
+    PUSH @SEGMENT_ACCOUNTS_LINKED_LIST
+    // stack: current_node_ptr, cur_len, retdest
+    DUP1
+    MLOAD_GENERAL
+    // stack: current_addr_key, current_node_ptr, cur_len', retdest
+    %assert_eq_const(@U256_MAX)
+    DUP1
+    %next_account
+    // stack: next_node_ptr, current_node_ptr, cur_len', retdest
+    DUP1
+    SWAP2
+    %next_initial_account
+    %assert_eq(store_initial_accounts_end) // next_node_ptr ==  current_node_ptr + node_size
+    // stack: next_node_ptr, cur_len', retdest
+    
+global debug_loop:
+loop_store_initial_accounts:
+    // stack: current_node_ptr, cur_len, retdest
+    %get_trie_data_size
+    // stack: cpy_ptr, current_node_ptr, cur_len, retdest
+    DUP2
+    %increment
+    MLOAD_GENERAL
+    // stack: nonce_ptr, cpy_ptr, current_node_ptr, cur_len, retdest
+    DUP1
+    %mload_trie_data // nonce
+    %append_to_trie_data
+    %increment
+    // stack: balance_ptr, cpy_ptr, current_node_ptr, cur_len, retdest
+    DUP1
+    %mload_trie_data // balance
+    %append_to_trie_data
+    %increment // The storage_root_ptr is not really necessary
+    // stack: storage_root_ptr_ptr, cpy_ptr, current_node_ptr, cur_len, retdest
+    DUP1
+    %mload_trie_data // storage_root_ptr
+    %append_to_trie_data
+    %increment
+    // stack: code_hash_ptr, cpy_ptr, current_node_ptr, cur_len, retdest
+    %mload_trie_data // code_hash
+    %append_to_trie_data
+    // stack: cpy_ptr, current_node_ptr, cur_len, retdest
+    DUP2
+    %add_const(2)
+    SWAP1
+    MSTORE_GENERAL // Store cpy_ptr
+    // stack: current_node_ptr, cur_len, retdest
+    SWAP1 PUSH @ACCOUNTS_LINKED_LISTS_NODE_SIZE 
+    ADD
+    SWAP1
+    // Check next node ptr validity and strict keys monotonicity
+    DUP1
+    MLOAD_GENERAL
+    // stack: current_addr_key, current_node_ptr, cur_len', retdest
+    SWAP1
+    DUP1
+    %next_account
+    // stack: next_node_ptr, current_node_ptr, current_addr_key, cur_len', retdest
+    DUP1
+    SWAP2
+    %next_initial_account
+    %assert_eq(store_initial_accounts_end_pop_key) // next_node_ptr ==  current_node_ptr + node_size
+    // stack: next_node_ptr, current_addr_key, cur_len', retdest
+    SWAP1
+    DUP2
+    MLOAD_GENERAL
+    %assert_gt // next_addr_key > current_addr_key
+    // stack: next_node_ptr, cur_len', retdest
+    %jump(loop_store_initial_accounts)
+
+store_initial_accounts_end_pop_key:
+    // stack: next_node_ptr, current_addr_key, cur_len', retdest
+    SWAP1 POP
+store_initial_accounts_end:
+    // stack: next_node_ptr, cur_len', retdest
+    %assert_eq_const(@SEGMENT_ACCOUNTS_LINKED_LIST)
+    // stack: cur_len, retdest
+    DUP1
+    %mstore_global_metadata(@GLOBAL_METADATA_INITIAL_ACCOUNTS_LINKED_LIST_LEN)
+    %mstore_global_metadata(@GLOBAL_METADATA_ACCOUNTS_LINKED_LIST_NEXT_AVAILABLE)
+    JUMP
+
+%macro insert_account_with_overwrite
+    %stack (addr_key, ptr) -> (addr_key, ptr, %%after)
+    %jump(insert_account_with_overwrite)
+%%after:
+%endmacro
+
+// Multiplies the value at the top of the stack, denoted by ptr/4, by 4
+// and aborts if ptr/4 >= mem[@GLOBAL_METADATA_ACCOUNTS_LINKED_LIST_NEXT_AVAILABLE]/4.
+// Also checks that ptr >= @SEGMENT_ACCOUNTS_LINKED_LIST.
+// This way, 4*ptr/4 must be pointing to the beginning of a node.
+// TODO: Maybe we should check here if the node has been deleted.
+%macro get_valid_account_ptr
+    // stack: ptr/4
+    // Check that the pointer is greater than the segment.
+    PUSH @SEGMENT_ACCOUNTS_LINKED_LIST
+    DUP2
+    %mul_const(4)
+    // stack: ptr, @SEGMENT_ACCOUNTS_LINKED_LIST, ptr/4
+    %increment %assert_gt
+    // stack: ptr/4
+    DUP1
+    PUSH 4
+    %mload_global_metadata(@GLOBAL_METADATA_ACCOUNTS_LINKED_LIST_NEXT_AVAILABLE)
+    // By construction, both @SEGMENT_ACCOUNTS_LINKED_LIST and the unscaled list len
+    // must be multiples of 4
+    DIV
+    // stack: @SEGMENT_ACCOUNTS_LINKED_LIST/4 + accounts_linked_list_len/4, ptr/4, ptr/4
+    %assert_gt
+    %mul_const(4)
+%endmacro
+
+global insert_account_with_overwrite:
+    // stack: addr_key, payload_ptr, retdest
+    PROVER_INPUT(linked_list::insert_account)
+    // stack: pred_ptr/4, addr_key, payload_ptr, retdest
+    %get_valid_account_ptr
+    // stack: pred_ptr, addr_key, payload_ptr, retdest
+    DUP1
+    MLOAD_GENERAL
+    DUP1
+    // stack: pred_addr_key, pred_addr_key, pred_ptr, addr_key, payload_ptr, retdest
+    DUP4 GT
+    DUP3 %eq_const(@SEGMENT_ACCOUNTS_LINKED_LIST)
+    ADD // OR
+    // If the predesessor is strictly smaller or the predecessor is the special
+    // node with key @U256_MAX (and hence we're inserting a new minimum), then
+    // we need to insert a new node.
+    %jumpi(insert_new_account)
+    // stack: pred_addr_key, pred_ptr, addr_key, payload_ptr, retdest
+    // If we are here we know that addr <= pred_addr. But this is only possible if pred_addr == addr.
+    DUP3
+    %assert_eq
+    
+    // stack: pred_ptr, addr_key, payload_ptr, retdest
+    // Check that this is not a deleted node
+    DUP1
+    %add_const(@ACCOUNTS_NEXT_NODE_PTR)
+    MLOAD_GENERAL
+    %jump_neq_const(@U256_MAX, account_found_with_overwrite)
+    // The storage key is not in the list.
+    PANIC
+
+account_found_with_overwrite:
+    // The address was already in the list
+    // stack: pred_ptr, addr_key, payload_ptr, retdest
+    // Load the payload pointer
+    %increment
+    // stack: payload_ptr_ptr, addr_key, payload_ptr, retdest
+    DUP3 MSTORE_GENERAL
+    %pop2
+    JUMP
+
+insert_new_account:
+    // stack: pred_addr_key, pred_ptr, addr_key, payload_ptr, retdest
+    POP
+    // get the value of the next address
+    %add_const(@ACCOUNTS_NEXT_NODE_PTR)
+    // stack: next_ptr_ptr, addr_key, payload_ptr, retdest
+    %mload_global_metadata(@GLOBAL_METADATA_ACCOUNTS_LINKED_LIST_NEXT_AVAILABLE)
+    DUP2
+    MLOAD_GENERAL
+    // stack: next_ptr, new_ptr, next_ptr_ptr, addr_key, payload_ptr, retdest
+    // Check that this is not a deleted node
+    DUP1
+    %eq_const(@U256_MAX)
+    %assert_zero
+    DUP1
+    MLOAD_GENERAL
+    // stack: next_addr_key, next_ptr, new_ptr, next_ptr_ptr, addr_key, payload_ptr, retdest
+    DUP5
+    // Here, (addr_key > pred_addr_key) || (pred_ptr == @SEGMENT_ACCOUNTS_LINKED_LIST).
+    // We should have (addr_key < next_addr_key), meaning the new value can be inserted between pred_ptr and next_ptr.
+    %assert_lt
+    // stack: next_ptr, new_ptr, next_ptr_ptr, addr_key, payload_ptr, retdest
+    SWAP2
+    DUP2
+    // stack: new_ptr, next_ptr_ptr, new_ptr, next_ptr, addr_key, payload_ptr, retdest
+    MSTORE_GENERAL
+    // stack: new_ptr, next_ptr, addr_key, payload_ptr, retdest
+    DUP1
+    DUP4
+    MSTORE_GENERAL
+    // stack: new_ptr, next_ptr, addr_key, payload_ptr, retdest
+    %increment
+    DUP1
+    DUP5
+    MSTORE_GENERAL
+    // stack: new_ptr + 1, next_ptr, addr_key, payload_ptr, retdest
+    %increment
+    DUP1
+    DUP5
+    %clone_account
+    MSTORE_GENERAL
+    %increment
+    DUP1
+    // stack: new_next_ptr, new_next_ptr, next_ptr, addr_key, payload_ptr, retdest
+    SWAP2
+    MSTORE_GENERAL
+    // stack: new_next_ptr, addr_key, payload_ptr, retdest
+    %increment
+    %mstore_global_metadata(@GLOBAL_METADATA_ACCOUNTS_LINKED_LIST_NEXT_AVAILABLE)
+    // stack: addr_key, payload_ptr, retdest
+    %pop2
+    JUMP
+
+
+/// Searches the account addr in the linked list.
+/// Returns 0 if the account was not found or `original_ptr` if it was already present.
+global search_account:
+    // stack: addr_key, retdest
+    PROVER_INPUT(linked_list::search_account)
+    // stack: pred_ptr/4, addr_key, retdest
+    %get_valid_account_ptr
+    // stack: pred_ptr, addr_key, retdest
+    DUP1
+    MLOAD_GENERAL
+    DUP1
+    // stack: pred_addr_key, pred_addr_key, pred_ptr, addr_key, retdest
+    DUP4 GT
+    DUP3 %eq_const(@SEGMENT_ACCOUNTS_LINKED_LIST)
+    ADD // OR
+    // If the predesessor is strictly smaller or the predecessor is the special
+    // node with key @U256_MAX (and hence we're inserting a new minimum), then
+    // we need to insert a new node.
+    %jumpi(account_not_found)
+    // stack: pred_addr_key, pred_ptr, addr_key, retdest
+    // If we are here we know that addr_key <= pred_addr_key. But this is only possible if pred_addr == addr.
+    DUP3
+    %assert_eq
+    
+    // stack: pred_ptr, addr_key, retdest
+    // Check that this is not a deleted node
+    DUP1
+    %add_const(@ACCOUNTS_NEXT_NODE_PTR)
+    MLOAD_GENERAL
+    %jump_neq_const(@U256_MAX, account_found)
+    // The storage key is not in the list.
+    PANIC
+
+account_found:
+    // The address was already in the list
+    // stack: pred_ptr, addr_key, retdest
+    // Load the payload pointer
+    %increment
+    MLOAD_GENERAL
+    // stack: orig_payload_ptr, addr_key, retdest
+    %stack (orig_payload_ptr, addr_key, retdest) -> (retdest, orig_payload_ptr)
+    JUMP
+
+account_not_found:
+    // stack: pred_addr_key, pred_ptr, addr_key, retdest
+    %stack (pred_addr_key, pred_ptr, addr_key, retdest) -> (retdest, 0)
+    JUMP
+
+%macro remove_account_from_linked_list
+    PUSH %%after
+    SWAP1
+    %jump(remove_account)
+%%after:
+%endmacro
+
+/// Removes the address and its value from the access list.
+/// Panics if the key is not in the list.
+global remove_account:
+    // stack: addr_key, retdest
+    PROVER_INPUT(linked_list::remove_account)
+    // stack: pred_ptr/4, addr_key, retdest
+    %get_valid_account_ptr
+    // stack: pred_ptr, addr_key, retdest
+    %add_const(@ACCOUNTS_NEXT_NODE_PTR)
+    // stack: next_ptr_ptr, addr_key, retdest
+    DUP1
+    MLOAD_GENERAL
+    // stack: next_ptr, next_ptr_ptr, addr_key, retdest
+    DUP1
+    MLOAD_GENERAL
+    // stack: next_addr_key, next_ptr, next_ptr_ptr, addr_key, retdest
+    DUP4
+    %assert_eq
+    // stack: next_ptr, next_ptr_ptr, addr_key, retdest
+    %add_const(@ACCOUNTS_NEXT_NODE_PTR)
+    // stack: next_next_ptr_ptr, next_ptr_ptr, addr_key, retdest
+    DUP1
+    MLOAD_GENERAL
+    // stack: next_next_ptr, next_next_ptr_ptr, next_ptr_ptr, addr_key, retdest
+    SWAP1
+    %mstore_u256_max
+    // stack: next_next_ptr, next_ptr_ptr, addr_key, retdest
+    MSTORE_GENERAL
+    POP
+    JUMP
+
+/// Called when an account is deleted: it deletes all slots associated with the account.
+global remove_all_account_slots:
+    // stack: addr_key, retdest
+    PROVER_INPUT(linked_list::remove_address_slots)
+    // pred_ptr/5, retdest
+    %get_valid_slot_ptr
+    // stack: pred_ptr, addr_key, retdest
+    // First, check that the previous address is not `addr`
+    DUP1 MLOAD_GENERAL
+    // stack: pred_addr_key, pred_ptr, addr_key, retdest
+    DUP3 EQ %jumpi(panic)
+    // stack: pred_ptr, addr_key, retdest
+    DUP1
+
+// Now, while the next address is `addr`, remove the next slot.
+remove_all_slots_loop:
+    // stack: pred_ptr, pred_ptr, addr_key, retdest
+    %add_const(@STORAGE_NEXT_NODE_PTR) DUP1 MLOAD_GENERAL
+    // stack: cur_ptr, cur_ptr_ptr, pred_ptr, addr_key, retdest
+    DUP1 %eq_const(@U256_MAX) %jumpi(remove_all_slots_end)
+    DUP1 %add_const(@STORAGE_NEXT_NODE_PTR) MLOAD_GENERAL 
+    // stack: next_ptr, cur_ptr, cur_ptr_ptr, pred_ptr, addr_key, retdest
+    SWAP1 DUP1
+    // stack: cur_ptr, cur_ptr, next_ptr, cur_ptr_ptr, pred_ptr, addr_key, retdest
+    MLOAD_GENERAL
+    DUP6 EQ ISZERO %jumpi(remove_all_slots_pop_and_end)
+    
+    // Remove slot: update the value in cur_ptr_ptr, and set cur_ptr+4 to @U256_MAX.
+    // stack: cur_ptr, next_ptr, cur_ptr_ptr, pred_ptr, addr_key, retdest
+    SWAP2 SWAP1
+    // stack: next_ptr, cur_ptr_ptr, cur_ptr, pred_ptr, addr_key, retdest
+    MSTORE_GENERAL
+    // stack: cur_ptr, pred_ptr, addr_key, retdest
+    %add_const(@STORAGE_NEXT_NODE_PTR) 
+    %mstore_u256_max
+    // stack: pred_ptr, addr_key, retdest
+    DUP1
+    %jump(remove_all_slots_loop)
+
+remove_all_slots_pop_and_end:
+    POP
+remove_all_slots_end:
+    // stack: next_ptr, cur_ptr_ptr, pred_ptr, addr_key, retdest
+    %pop4 JUMP
+
+%macro remove_all_account_slots
+    %stack (addr_key) -> (addr_key, %%after)
+    %jump(remove_all_account_slots)
+%%after:
+%endmacro
+
+%macro read_account_from_addr
+    %stack (addr) -> (addr, %%after)
+    %addr_to_state_key
+    %jump(search_account)
+%%after:
+    // stack: account_ptr
+%endmacro
+
+%macro nonce_from_ptr
+    %mload_trie_data
+%endmacro
+
+%macro balance_from_ptr
+    %increment
+    %mload_trie_data
+%endmacro
+
+%macro first_account
+    // stack: empty
+    PUSH @SEGMENT_ACCOUNTS_LINKED_LIST
+    %next_account
+%endmacro
+
+%macro first_initial_account
+    // stack: empty
+    PUSH @SEGMENT_ACCOUNTS_LINKED_LIST
+    %next_initial_account
+%endmacro
+
+%macro next_account
+    // stack: node_ptr
+    %add_const(@ACCOUNTS_NEXT_NODE_PTR)
+    MLOAD_GENERAL
+    // stack: next_node_ptr
+%endmacro
+
+%macro next_initial_account
+    // stack: node_ptr
+    %add_const(@ACCOUNTS_LINKED_LISTS_NODE_SIZE)
+    // stack: next_node_ptr
+%endmacro
+
+%macro set_nonce
+    // stack: address, nonce
+    %read_account_from_addr
+    // stack: payload_ptr, nonce
+    DUP1 %assert_nonzero
+    // stack: nonce_ptr, nonce
+    %mstore_trie_data
+    // stack: (empty)
+%endmacro
+
+%macro read_nonce
+    // stack: address
+    %mpt_read_state_trie
+    // stack: account_ptr
+    // The nonce is the first account field, so we deref the account pointer itself.
+    // Note: We don't need to handle account_ptr=0, as trie_data[0] = 0,
+    // so the deref will give 0 (the default nonce) as desired.
+    %mload_trie_data
+    // stack: nonce
+%endmacro
+
+%macro read_balance
+    // stack: address
+    %mpt_read_state_trie
+    // stack: account_ptr
+    DUP1 ISZERO %jumpi(%%retzero) // If the account pointer is null, return 0.
+    %add_const(1)
+    // stack: balance_ptr
+    %mload_trie_data
+    // stack: balance
+%%retzero:
+    // stack: 0
+%endmacro
diff --git a/evm_arithmetization/src/cpu/kernel/asm/mpt/linked_list/final_tries.asm b/evm_arithmetization/src/cpu/kernel/asm/linked_list/final_tries.asm
similarity index 98%
rename from evm_arithmetization/src/cpu/kernel/asm/mpt/linked_list/final_tries.asm
rename to evm_arithmetization/src/cpu/kernel/asm/linked_list/final_tries.asm
index 53093f4f4..3cfd798b4 100644
--- a/evm_arithmetization/src/cpu/kernel/asm/mpt/linked_list/final_tries.asm
+++ b/evm_arithmetization/src/cpu/kernel/asm/linked_list/final_tries.asm
@@ -33,7 +33,10 @@ after_insert_all_slots:
     // stack: storage_ptr_ptr', key, root_ptr, account_ptr_ptr, retdest
     DUP4
     %increment
+global debug_account_ptr_ptr:
     MLOAD_GENERAL
+
+global debug_account_ptr:
     %stack
         (payload_ptr, storage_ptr_ptr_p, key, root_ptr, account_ptr_ptr) -> 
         (root_ptr, 64, key, payload_ptr, after_insert_account, account_ptr_ptr, storage_ptr_ptr_p)
@@ -119,7 +122,9 @@ global delete_removed_accounts:
     %add_const(2)
     MLOAD_GENERAL // get initial payload_ptr
     %add_const(2) // storage_root_ptr_ptr = payload_ptr + 2
+global debug_loading_storage_root_ptr:
     %mload_trie_data
+global debug_storage_root_ptr:
     // stack: storage_root_ptr, key, account_ptr_ptr, root_ptr, storage_ptr_ptr, retdest
     DUP3
     %increment
@@ -164,6 +169,7 @@ after_mpt_delete:
 // Pre stack: addr, root_ptr, storage_ptr_ptr, retdest
 // Post stack: new_root_ptr, storage_ptr_ptr'.
 delete_removed_slots:
+global debug_delete_removed_slots:
     // stack: addr, root_ptr, storage_ptr_ptr, retdest
     DUP3
     MLOAD_GENERAL
diff --git a/evm_arithmetization/src/cpu/kernel/asm/mpt/linked_list/initial_tries.asm b/evm_arithmetization/src/cpu/kernel/asm/linked_list/initial_tries.asm
similarity index 92%
rename from evm_arithmetization/src/cpu/kernel/asm/mpt/linked_list/initial_tries.asm
rename to evm_arithmetization/src/cpu/kernel/asm/linked_list/initial_tries.asm
index df4762a51..d9b92687c 100644
--- a/evm_arithmetization/src/cpu/kernel/asm/mpt/linked_list/initial_tries.asm
+++ b/evm_arithmetization/src/cpu/kernel/asm/linked_list/initial_tries.asm
@@ -25,14 +25,14 @@ set_initial_state_trie_after:
 // Post stack: new_root_ptr. // The value of new_root_ptr shouldn't change
 global insert_all_initial_accounts:
     // stack: account_ptr_ptr, root_ptr, storage_ptr_ptr, retdest
-    SWAP2
-    DUP3
-    MLOAD_GENERAL
-    // stack: key, storage_ptr_ptr, root_ptr, account_ptr_ptr, retdest
-    DUP4
+    DUP1
     %mload_global_metadata(@GLOBAL_METADATA_INITIAL_ACCOUNTS_LINKED_LIST_LEN)
     EQ
     %jumpi(no_more_accounts)
+    // stack: account_ptr_ptr, root_ptr, storage_ptr_ptr, retdest
+    SWAP2
+    DUP3
+    MLOAD_GENERAL
     // stack: key, storage_ptr_ptr, root_ptr, account_ptr_ptr, retdest
     PUSH after_mpt_read
     DUP2
@@ -46,6 +46,7 @@ after_mpt_read:
     %mload_trie_data
     %add_const(2)
     %mload_trie_data
+global debug_trie_storage_root:
     // stack: trie_storage_root, trie_account_ptr_ptr, key, storage_ptr_ptr, root_ptr, account_ptr_ptr, retdest
     SWAP1
     // stack: trie_account_ptr_ptr, trie_storage_root, key, storage_ptr_ptr, root_ptr, account_ptr_ptr, retdest
@@ -76,8 +77,7 @@ after_insert_all_initial_slots:
     %jump(insert_all_initial_accounts)
 
 no_more_accounts:
-    // stack: key, storage_ptr_ptr, root_ptr, account_ptr_ptr, retdest
-    %stack (key, storage_ptr_ptr, root_ptr, account_ptr_ptr, retdest) ->(retdest, root_ptr)
+    %stack (account_ptr_ptr, root_ptr, storage_ptr_ptr, retdest) ->(retdest, root_ptr)
     JUMP
 
 // Insert all slots before the account key changes
@@ -127,3 +127,15 @@ after_insert_slot:
     SWAP1
     %jump(insert_all_initial_slots)
 
+%macro store_initial_state
+    // stack: (empty)
+    PUSH %%after
+    %jump(store_initial_state)
+%%after:
+%endmacro
+
+global store_initial_state:
+    // stack: retdest
+    %store_initial_accounts
+    %store_initial_slots
+    JUMP
\ No newline at end of file
diff --git a/evm_arithmetization/src/cpu/kernel/asm/linked_list/storage_linked_list.asm b/evm_arithmetization/src/cpu/kernel/asm/linked_list/storage_linked_list.asm
new file mode 100644
index 000000000..6d69ac0e4
--- /dev/null
+++ b/evm_arithmetization/src/cpu/kernel/asm/linked_list/storage_linked_list.asm
@@ -0,0 +1,496 @@
+/// The storage linked list is stored in SEGMENT_STORAGE_LINKED_LIST in the kernel memory (context=0).
+/// The length of the segment is stored in GLOBAL_METADATA_STORAGE_LINKED_LIST_NEXT_AVAILABLE.
+/// Searching and inserting is done by guessing the predecessor in the list.
+/// If the storage key isn't found in the array, it is inserted 
+/// at the correct location. This linked list is used to keep track of
+/// inserted and deleted slots during the execution, so that the 
+/// initial and final MPT state tries can be reconstructed at the end of the execution.
+/// An empty storage linked list is written as
+/// [@U256_MAX, _, _, _, @SEGMENT_ACCOUNTS_LINKED_LIST] in SEGMENT_ACCOUNTS_LINKED_LIST.
+/// Each slot is encoded using 5 values:
+/// - 0: The account key
+/// - 1: The slot key
+/// - 2: The slot value.
+/// - 3: The initial slot value.
+/// - 4: A ptr (in segment @SEGMENT_ACCOUNTS_LINKED_LIST) to the next node in the list.
+
+%macro store_initial_slots
+    PUSH %%after
+    %jump(store_initial_slots)
+%%after:
+%endmacro
+
+
+/// Iterates over the initial storage linked list and copies the slots values into
+/// the initial values.
+/// Computes the length of `SEGMENT_STORAGE_LINKED_LIST` and 
+/// checks against `GLOBAL_METADATA_STORAGE_LINKED_LIST_NEXT_AVAILABLE`.
+/// It also checks that the next node address is current address + 5
+/// and that all keys are strictly increasing.
+/// NOTE: It may be more efficient to check that the next node addres != U256_MAX
+/// (i.e. node was not deleted) and ensure that no node with repeated key
+/// is ever read.
+global store_initial_slots:
+    // stack: retdest
+    PUSH @STORAGE_LINKED_LISTS_NODE_SIZE
+    PUSH @SEGMENT_STORAGE_LINKED_LIST
+    ADD
+    // stack: cur_len, retdest
+    PUSH @SEGMENT_STORAGE_LINKED_LIST
+    DUP1
+    MLOAD_GENERAL
+    // stack: current_addr_key, current_node_ptr, cur_len, retdest
+    %assert_eq_const(@U256_MAX)
+
+    // stack: current_node_ptr, cur_len', retdest
+    DUP1
+    %next_slot
+    // stack: next_node_ptr, current_node_ptr, cur_len, retdest
+    DUP1
+    SWAP2
+    %next_initial_slot
+    %assert_eq(store_initial_slots_end) // next_node_ptr == current_node_ptr + node_size
+    // stack: next_node_ptr, cur_len', retdest
+ 
+loop_store_initial_slots:
+    // stack: current_node_ptr, cur_len, retdest
+    DUP1
+    %add_const(2)
+    MLOAD_GENERAL
+    // stack: value, current_node_ptr, cur_len, retdest
+    DUP2
+    %add_const(@STORAGE_COPY_PAYLOAD_PTR)
+    // stack: cpy_value_ptr, value, current_node_ptr, cur_len, retdest
+    SWAP1
+    MSTORE_GENERAL // Store cpy_value
+    // stack: current_node_ptr, cur_len, retdest
+    SWAP1 PUSH @STORAGE_LINKED_LISTS_NODE_SIZE
+    ADD
+    SWAP1
+    // Check correctness of next node ptr and strict key monotonicity.
+    DUP1
+    MLOAD_GENERAL
+    // stack: current_addr_key, current_node_ptr, cur_len', retdest
+    SWAP1
+    DUP1
+    %increment
+    MLOAD_GENERAL
+    // stack: current_slot_key, current_node_ptr, current_addr_key, cur_len', retdest
+    SWAP1
+    DUP1
+    %next_slot
+    // stack: next_node_ptr, current_node_ptr, current_slot_key, current_addr_key, cur_len', retdest
+    DUP1
+    SWAP2
+    %next_initial_slot
+    %assert_eq(store_initial_slots_end_pop_keys) // next_node_ptr == current_node_ptr + node_size
+    // stack: next_node_ptr, current_slot_key, current_addr_key, cur_len', retdest
+    DUP1
+    DUP1
+    %increment
+    MLOAD_GENERAL
+    // stack: next_node_slot_key, next_node_ptr, next_node_ptr, current_slot_key, current_addr_key, cur_len', retdest
+    SWAP1
+    MLOAD_GENERAL
+    // stack: next_node_addr_key, next_node_slot_key, next_node_ptr, current_slot_key, current_addr_key, cur_len', retdest
+    SWAP3
+    LT
+    // stack: current_slot_key > next_node_slot_key, next_node_ptr, next_node_addr_key, current_addr_key, cur_len', retdest
+    SWAP2
+    SWAP1
+    SWAP3
+    // stack: current_addr_key, next_node_addr_key, current_slot_key > next_node_slot_key, next_node_ptr, cur_len', retdest
+    DUP2
+    DUP2
+    EQ
+    // stack: current_addr_key == next_node_addr_key, current_addr_key, next_node_addr_key, current_slot_key > next_node_slot_key, next_node_ptr, cur_len', retdest
+    SWAP1
+    SWAP3
+    MUL // AND
+    // stack  current_slot_key > next_node_slot_key AND current_addr_key == next_node_addr_key, next_node_addr_key, current_addr_key, next_node_ptr, cur_len', retdest
+    SWAP2
+    LT
+    ADD // OR
+    %assert_nonzero
+    %jump(loop_store_initial_slots)
+
+store_initial_slots_end_pop_keys:
+    // stack: next_node_ptr, current_slot_key, current_addr_key, cur_len', retdest
+    SWAP2
+    %pop2
+
+store_initial_slots_end:
+    // stack: next_node_ptr, cur_len', retdest
+    %assert_eq_const(@SEGMENT_STORAGE_LINKED_LIST)
+    
+    // stack: cur_len, retdest
+    DUP1
+    %mstore_global_metadata(@GLOBAL_METADATA_INITIAL_STORAGE_LINKED_LIST_LEN)
+    %mstore_global_metadata(@GLOBAL_METADATA_STORAGE_LINKED_LIST_NEXT_AVAILABLE)
+    JUMP
+
+
+// Multiplies the value at the top of the stack, denoted by ptr/5, by 5
+// and aborts if ptr/5 >= (mem[@GLOBAL_METADATA_ACCOUNTS_LINKED_LIST_NEXT_AVAILABLE] - @SEGMENT_STORAGE_LINKED_LIST)/5.
+// This way, @SEGMENT_STORAGE_LINKED_LIST + 5*ptr/5 must be pointing to the beginning of a node.
+// TODO: Maybe we should check here if the node has been deleted.
+%macro get_valid_slot_ptr
+    // stack: ptr/5
+    DUP1
+    PUSH 5
+    PUSH @SEGMENT_STORAGE_LINKED_LIST
+    // stack: segment, 5, ptr/5, ptr/5
+    %mload_global_metadata(@GLOBAL_METADATA_STORAGE_LINKED_LIST_NEXT_AVAILABLE)
+    SUB
+    // stack: accessed_strg_keys_len, 5, ptr/5, ptr/5
+    // By construction, the unscaled list len must be multiple of 5
+    DIV
+    // stack: accessed_strg_keys_len/5, ptr/5, ptr/5
+    %assert_gt
+    %mul_const(5)
+    %add_const(@SEGMENT_STORAGE_LINKED_LIST)
+%endmacro
+
+/// Inserts the pair (address_key, storage_key) and a new payload pointer into the linked list if it is not already present,
+/// or modifies its payload if it was already present.
+global insert_slot:
+    // stack: addr_key, key, value, retdest
+    PROVER_INPUT(linked_list::insert_slot)
+    // stack: pred_ptr/5, addr_key, key, value, retdest
+    %get_valid_slot_ptr
+
+    // stack: pred_ptr, addr_key, key, value, retdest
+    DUP1
+    MLOAD_GENERAL
+    DUP1
+    // stack: pred_addr_key, pred_addr_key, pred_ptr, addr_key, key, value, retdest
+    DUP4 
+    GT
+    DUP3 %eq_const(@SEGMENT_STORAGE_LINKED_LIST)
+    ADD // OR
+    // If the predesessor is strictly smaller or the predecessor is the special
+    // node with key @U256_MAX (and hence we're inserting a new minimum), then
+    // we need to insert a new node.
+    %jumpi(insert_new_slot)
+    // stack: pred_addr_key, pred_ptr, addr_key, key, payload_ptr, retdest
+    // If we are here we know that addr <= pred_addr. But this is only possible if pred_addr == addr.
+    DUP3
+    %assert_eq
+    // stack: pred_ptr, addr_key, key, value, retdest
+    DUP1
+    %increment
+    MLOAD_GENERAL
+    // stack: pred_key, pred_ptr, addr_key, key, value, retdest
+    DUP1 DUP5
+    GT
+    %jumpi(insert_new_slot)
+    // stack: pred_key, pred_ptr, addr_key, key, value, retdest
+    DUP4
+    // We know that key <= pred_key. It must hold that pred_key == key.
+    %assert_eq
+    
+    // stack: pred_ptr, addr_key, key, value, retdest
+    // Check that this is not a deleted node
+    DUP1
+    %add_const(@STORAGE_NEXT_NODE_PTR)
+    MLOAD_GENERAL
+    %jump_neq_const(@U256_MAX, slot_found_write_value)
+    // The storage key is not in the list.
+    PANIC
+
+insert_new_slot:
+    // stack: pred_addr or pred_key, pred_ptr, addr_key, key, value, retdest
+    POP
+    // get the value of the next address
+    %add_const(@STORAGE_NEXT_NODE_PTR)
+    // stack: next_ptr_ptr, addr_key, key, value, retdest
+    %mload_global_metadata(@GLOBAL_METADATA_STORAGE_LINKED_LIST_NEXT_AVAILABLE)
+    DUP2
+    MLOAD_GENERAL
+    // stack: next_ptr, new_ptr, next_ptr_ptr, addr_key, key, value, retdest
+    // Check that this is not a deleted node
+    DUP1
+    %eq_const(@U256_MAX)
+    %assert_zero
+    DUP1
+    MLOAD_GENERAL
+    // stack: next_addr_key, next_ptr, new_ptr, next_ptr_ptr, addr_key, key, value, retdest
+    DUP1
+    DUP6
+    // Here, (addr_key > pred_addr_key) || (pred_ptr == @SEGMENT_ACCOUNTS_LINKED_LIST).
+    // We should have (addr_key < next_addr_key), meaning the new value can be inserted between pred_ptr and next_ptr.
+    LT
+    %jumpi(next_node_ok)
+    // If addr_key <= next_addr_key, then it addr must be equal to next_addr
+    // stack: next_addr_key, next_ptr, new_ptr, next_ptr_ptr, addr_key, key, value, retdest
+    DUP5
+    %assert_eq
+    // stack: next_ptr, new_ptr, next_ptr_ptr, addr_key, key, value, retdest
+    DUP1
+    %increment
+    MLOAD_GENERAL
+    // stack: next_key, next_ptr, new_ptr, next_ptr_ptr, addr_key, key, value, retdest
+    DUP1 // This is added just to have the correct stack in next_node_ok
+    DUP7
+    // The next key must be strictly larger
+    %assert_lt
+
+next_node_ok:
+    // stack: next_addr or next_key, next_ptr, new_ptr, next_ptr_ptr, addr_key, key, value, retdest
+    POP
+    // stack: next_ptr, new_ptr, next_ptr_ptr, addr_key, key, value, retdest
+    SWAP2
+    DUP2
+    // stack: new_ptr, next_ptr_ptr, new_ptr, next_ptr, addr_key, key, value, retdest
+    MSTORE_GENERAL
+    // stack: new_ptr, next_ptr, addr_key, key, value, retdest
+    // Write the address in the new node
+    DUP1
+    DUP4
+    MSTORE_GENERAL
+    // stack: new_ptr, next_ptr, addr_key, key, value, retdest
+    // Write the key in the new node
+    %increment
+    DUP1
+    DUP5
+    MSTORE_GENERAL
+    // stack: new_ptr + 1, next_ptr, addr_key, key, value, retdest
+    // Write the value in the linked list.
+    %increment
+    DUP1 %increment
+    // stack: new_ptr+3, new_value_ptr, next_ptr, addr_key, key, value, retdest
+    %stack (new_cloned_value_ptr, new_value_ptr, next_ptr, addr_key, key, value, retdest)
+        -> (value, new_cloned_value_ptr, value, new_value_ptr, new_cloned_value_ptr, next_ptr, retdest)
+    MSTORE_GENERAL // Store copied value.
+    MSTORE_GENERAL // Store value.
+
+    // stack: new_ptr + 3, next_ptr, retdest
+    %increment
+    DUP1
+    // stack: new_next_ptr_ptr, new_next_ptr_ptr, next_ptr, retdest
+    SWAP2
+    MSTORE_GENERAL
+    // stack: new_next_ptr_ptr, retdest
+    %increment
+    %mstore_global_metadata(@GLOBAL_METADATA_STORAGE_LINKED_LIST_NEXT_AVAILABLE)
+    // stack: retdest
+    JUMP
+
+slot_found_write_value:
+    // stack: pred_ptr, addr_key, key, value, retdest
+    %add_const(2)
+    %stack (payload_ptr, addr_key, key, value) -> (value, payload_ptr)
+    MSTORE_GENERAL
+    // stack: retdest
+    JUMP
+
+%macro insert_slot
+    // stack: addr, slot, value
+    %addr_to_state_key
+    SWAP1
+    %slot_to_storage_key
+    %stack (slot_key, addr_key, value) -> (addr_key, slot_key, value, %%after)
+    %jump(insert_slot)
+%%after:
+    // stack: (empty)
+%endmacro
+
+%macro insert_slot_from_addr_key
+    // stack: addr_key, slot_key, value
+    SWAP1
+    %slot_to_storage_key
+    %stack (slot_key, addr_key, value) -> (addr_key, slot_key, value, %%after)
+    %jump(insert_slot)
+%%after:
+    // stack: (empty)
+%endmacro
+
+
+%macro search_slot_from_addr_key
+    // stack: state_key, slot
+    SWAP1
+    %slot_to_storage_key
+    %stack (storage_key, state_key) -> (state_key, storage_key, %%after)
+    %jump(search_slot)
+%%after:
+%endmacro
+
+/// Searches the pair (address_key, storage_key) in the storage the linked list.
+/// Returns 0 if the storage key was inserted, or the current `value` if it was already present.
+global search_slot:
+    // stack: addr_key, key, retdest
+    PROVER_INPUT(linked_list::search_slot)
+    // stack: pred_ptr/5, addr_key, key, retdest
+    %get_valid_slot_ptr
+
+    // stack: pred_ptr, addr_key, key, retdest
+    DUP1
+    MLOAD_GENERAL
+    DUP1
+    // stack: pred_addr_key, pred_addr_key, pred_ptr, addr_key, key, retdest
+    DUP4 
+    GT
+    DUP3 %eq_const(@SEGMENT_STORAGE_LINKED_LIST)
+    ADD // OR
+    // If the predesessor is strictly smaller or the predecessor is the special
+    // node with key @U256_MAX (and hence we're inserting a new minimum), then
+    // the slot was not found
+    %jumpi(slot_not_found)
+    // stack: pred_addr_key, pred_ptr, addr_key, key, retdest
+    // If we are here we know that addr <= pred_addr. But this is only possible if pred_addr == addr.
+    DUP3
+    %assert_eq
+    // stack: pred_ptr, addr_key, key, retdest
+    DUP1
+    %increment
+    MLOAD_GENERAL
+    // stack: pred_key, pred_ptr, addr_key, key, retdest
+    DUP1 DUP5
+    GT
+    %jumpi(slot_not_found)
+    // stack: pred_key, pred_ptr, addr_key, key, retdest
+    DUP4
+    // We know that key <= pred_key. It must hold that pred_key == key.
+    %assert_eq
+    // stack: pred_ptr, addr_key, key, retdest
+    
+    // stack: pred_ptr, addr_key, key, retdest
+    // Check that this is not a deleted node
+    DUP1
+    %add_const(@STORAGE_NEXT_NODE_PTR)
+    MLOAD_GENERAL
+    %jump_neq_const(@U256_MAX, slot_found_no_write)
+    // The storage key is not in the list.
+    PANIC
+slot_not_found:    
+    // stack: pred_addr_or_pred_key, pred_ptr, addr_key, key, retdest
+    %stack (pred_addr_or_pred_key, pred_ptr, addr_key, key, retdest)
+        -> (retdest, 0)
+    JUMP
+
+slot_found_no_write:
+    // The slot was already in the list
+    // stack: pred_ptr, addr_key, key, retdest
+    // Load the old value
+    %add_const(2)
+    MLOAD_GENERAL
+    // stack: old_value, addr_key, key, retdest
+    %stack (old_value, addr_key, key, retdest) -> (retdest, old_value)
+    JUMP
+
+/// Removes the storage key and its value from the list.
+/// Panics if the key is not in the list.
+global remove_slot:
+    // stack: addr_key, key, retdest
+    PROVER_INPUT(linked_list::remove_slot)
+    // stack: pred_ptr/5, addr_key, key, retdest
+    %get_valid_slot_ptr
+    // stack: pred_ptr, addr_key, key, retdest
+    %add_const(@STORAGE_NEXT_NODE_PTR)
+    // stack: next_ptr_ptr, addr_key, key, retdest
+    DUP1
+    MLOAD_GENERAL
+    // stack: next_ptr, next_ptr_ptr, addr_key, key, retdest
+    DUP1
+    MLOAD_GENERAL
+    // stack: next_addr_key, next_ptr, next_ptr_ptr, addr_key, key, retdest
+    DUP4
+    %assert_eq
+    // stack: next_ptr, next_ptr_ptr, addr_key, key, retdest
+    DUP1
+    %increment
+    MLOAD_GENERAL
+    // stack: next_key, next_ptr, next_ptr_ptr, addr_key, key, retdest
+    DUP5
+    %assert_eq
+    // stack: next_ptr, next_ptr_ptr, addr_key, key, retdest
+    %add_const(@STORAGE_NEXT_NODE_PTR)
+    // stack: next_next_ptr_ptr, next_ptr_ptr, addr_key, key, retdest
+    DUP1
+    MLOAD_GENERAL
+    // stack: next_next_ptr, next_next_ptr_ptr, next_ptr_ptr, addr_key, key, retdest
+    // Mark the next node as deleted
+    SWAP1
+    %mstore_u256_max
+    // stack: next_next_ptr, next_ptr_ptr, addr_key, key, retdest
+    MSTORE_GENERAL
+    %pop2
+    JUMP
+
+%macro remove_slot_from_addr_key
+    // stack: addr_key, slot
+    SWAP1
+    %slot_to_storage_key
+    %stack (key, addr_key) -> (addr_key, key, %%after)
+    %jump(remove_slot)
+%%after:
+%endmacro
+
+%macro remove_slot_from_addr
+    // stack: addr, slot
+    %addr_to_state_key
+    SWAP1
+    %slot_to_storage_key
+    %stack (key, addr_key) -> (addr_key, key, %%after)
+    %jump(remove_slot)
+%%after:
+%endmacro
+
+%macro read_slot_from_current_addr
+    // stack: slot
+    %slot_to_storage_key
+    %stack (storage_key) -> (storage_key, %%after)
+    %address
+    %addr_to_state_key
+    // stack: addr_key, storage_key,  %%after
+    %jump(search_slot)
+%%after:
+    // stack: slot_value
+%endmacro
+
+%macro read_slot_from_addr
+    // stack: address, slot
+    SWAP1
+    %slot_to_storage_key
+    %stack (storage_key, address) -> (address, storage_key, %%after)
+    %addr_to_state_key
+    // stack: addr_key, storage_key, %%after
+    %jump(search_slot)
+%%after:
+    // stack: slot_value
+%endmacro
+
+%macro read_slot_from_addr_key
+    // stack: state_key, slot
+    SWAP1
+    %slot_to_storage_key
+    %stack (storage_key, state_key) -> (state_key, storage_key, %%after)
+    %jump(search_slot)
+%%after:
+    // stack: slot_ptr
+%endmacro
+
+%macro first_slot
+    // stack: empty
+    PUSH @SEGMENT_STORAGE_LINKED_LIST
+    %next_slot
+%endmacro
+
+%macro first_initial_slot
+    // stack: empty
+    PUSH @SEGMENT_STORAGE_LINKED_LIST
+    %next_initial_slot
+%endmacro
+
+%macro next_slot
+    // stack: node_ptr
+    %add_const(@STORAGE_NEXT_NODE_PTR)
+    MLOAD_GENERAL
+    // stack: next_node_ptr
+%endmacro
+
+%macro next_initial_slot
+    // stack: node_ptr
+    %add_const(@STORAGE_LINKED_LISTS_NODE_SIZE)
+    // stack: next_node_ptr
+%endmacro
\ No newline at end of file
diff --git a/evm_arithmetization/src/cpu/kernel/asm/linked_list/type2/final_tries.asm b/evm_arithmetization/src/cpu/kernel/asm/linked_list/type2/final_tries.asm
new file mode 100644
index 000000000..014b84931
--- /dev/null
+++ b/evm_arithmetization/src/cpu/kernel/asm/linked_list/type2/final_tries.asm
@@ -0,0 +1,100 @@
+// Given a pointer `root_ptr` to the root of a trie, insert all the final nodes in
+// the state_linked_list starting at `node_ptr_ptr`.
+// Pre stack: node_ptr_ptr, root_ptr, retdest
+// Post stack: new_root_ptr. // The value of new_root_ptr shouldn't change
+global insert_all_final_nodes:
+    // stack: node_ptr_ptr, root_ptr, retdest
+    SWAP1 DUP2
+    MLOAD_GENERAL
+    // stack: key, root_ptr, node_ptr_ptr, retdest
+    DUP1
+    %eq_const(@U256_MAX)
+    %jumpi(no_more_nodes)
+    // stack: key, root_ptr, node_ptr_ptr, retdest
+    PUSH after_smt_insert
+    DUP4
+    %increment // Get the final value
+    MLOAD_GENERAL
+    // stack: value, after_smt_insert, key, root_ptr, node_ptr_ptr, retdest
+    DUP3
+    %split_key
+    // stack: k0, k1, k2, k3, value, after_smt_insert, key, root_ptr, node_ptr_ptr, retdest
+    PUSH 0
+    DUP9
+    // stack: root_ptr, level, k0, k1, k2, k3, after_smt_insert, key, root_ptr, node_ptr_ptr, retdest
+    %jump(smt_insert)
+after_smt_insert:
+    //stack: root_ptr', key, root_ptr, node_ptr_ptr, retdest
+    %stack (new_root_ptr, key, root_ptr, next_node_ptr_ptr) -> (next_node_ptr_ptr, new_root_ptr)
+    %next_node
+    // stack: node_ptr_ptr', root_ptr', retdest
+    %jump(insert_all_final_nodes)
+
+no_more_nodes:
+    // stack: key, root_ptr, node_ptr_ptr, retdest
+    %stack (key, root_ptr, node_ptr_ptr, retdest) ->(retdest, root_ptr)
+    JUMP
+
+// Delete all the values in the final state linked list which where deleted from the initial state.
+// Pre stack: node_ptr_ptr, root_ptr, retdest
+// Post stack: new_root_ptr.
+global delete_removed_nodes:
+    // stack: node_ptr_ptr, root_ptr, retdest
+    DUP1
+    // We assume that the size of the initial state linked list, containing the nodes
+    // of the initial state, was stored at `@GLOBAL_METADATA_INITIAL_ACCOUNTS_LINKED_LIST_LEN`.
+    %mload_global_metadata(@GLOBAL_METADATA_INITIAL_ACCOUNTS_LINKED_LIST_LEN)
+    // The initial state linked list was stored at and addresses smaller than `@GLOBAL_METADATA_INITIAL_ACCOUNTS_LINKED_LIST_LEN`.
+    // If we also know that `@SEGMENT_ACCOUNT_LINKED_LIST <= node_ptr_ptr`, for deleting node at `node_ptr_ptr` it
+    // suffices to check that `node_ptr_ptr` != `@GLOBAL_METADATA_INITIAL_ACCOUNTS_LINKED_LIST_LEN`
+    EQ
+    %jumpi(delete_removed_nodes_end)
+    // stack: node_ptr_ptr, root_ptr, retdest
+    DUP1
+    %next_node
+    %eq_const(@U256_MAX) // If the next node pointer is @U256_MAX, the node was deleted
+    %jumpi(delete_node)
+    // stack: node_ptr_ptr, root_ptr, retdest
+    %next_initial_node
+    %jump(delete_removed_nodes)
+
+delete_removed_nodes_end:
+    // stack: account_ptr_ptr, root_ptr, retdest
+    %stack (node_ptr_ptr, root_ptr, retdest) -> (retdest, root_ptr)
+    JUMP
+
+delete_node:
+    // stack: node_ptr_ptr, root_ptr, retdest
+    DUP1
+    MLOAD_GENERAL
+    %stack (key, node_ptr_ptr, root_ptr) -> (root_ptr, key, after_mpt_delete, node_ptr_ptr)
+    %jump(smt_delete)
+after_mpt_delete:
+    // stack: root_ptr', node_ptr_ptr, retdest
+    SWAP1
+    %next_initial_node
+    %jump(delete_removed_nodes)
+
+
+global set_final_tries:
+    PUSH set_final_tries_after
+    %mload_global_metadata(@GLOBAL_METADATA_STATE_TRIE_ROOT)
+    %first_initial_node // Skip the first node.
+    %jump(delete_removed_nodes)
+set_final_tries_after:
+    // stack: new_state_root
+    PUSH set_final_tries_after_after SWAP1
+    // stack: new_state_root, set_final_tries_after_after
+    %first_node
+    %jump(insert_all_final_nodes)
+set_final_tries_after_after:
+    //stack: new_state_root
+    %mstore_global_metadata(@GLOBAL_METADATA_STATE_TRIE_ROOT)
+    JUMP
+
+%macro set_final_tries
+    // stack: (empty)
+    PUSH %%after
+    %jump(set_final_tries)
+%%after:
+%endmacro
diff --git a/evm_arithmetization/src/cpu/kernel/asm/linked_list/type2/initial_tries.asm b/evm_arithmetization/src/cpu/kernel/asm/linked_list/type2/initial_tries.asm
new file mode 100644
index 000000000..a088fb16f
--- /dev/null
+++ b/evm_arithmetization/src/cpu/kernel/asm/linked_list/type2/initial_tries.asm
@@ -0,0 +1,59 @@
+
+global set_initial_state_trie:
+    // stack: retdest
+    PUSH set_initial_state_trie_after
+    %mload_global_metadata(@GLOBAL_METADATA_STATE_TRIE_ROOT)
+    %first_initial_node // Skip the first node.
+    %jump(insert_all_initial_nodes)
+set_initial_state_trie_after:
+    //stack: new_state_root
+    %mstore_global_metadata(@GLOBAL_METADATA_STATE_TRIE_ROOT)
+    JUMP
+
+%macro set_initial_state_trie
+    // stack: (empty)
+    PUSH %%after
+    %jump(set_initial_state_trie)
+%%after:
+%endmacro
+
+// Given a pointer `root_ptr` to the root of a trie, insert all the initial nodes in
+// the state_linked_list starting at `node_ptr_ptr`.
+// Pre stack: node_ptr_ptr, root_ptr, retdest
+// Post stack: new_root_ptr. // The value of new_root_ptr shouldn't change
+global insert_all_initial_nodes:
+    // stack: node_ptr_ptr, root_ptr, retdest
+    SWAP1 DUP2
+    MLOAD_GENERAL
+    // stack: key, root_ptr, node_ptr_ptr, retdest
+    DUP3
+    %mload_global_metadata(@GLOBAL_METADATA_INITIAL_ACCOUNTS_LINKED_LIST_LEN)
+    EQ
+    %jumpi(no_more_nodes)
+    // stack: key, root_ptr, node_ptr_ptr, retdest
+    PUSH after_smt_read
+    DUP2
+    %split_key
+    // stack: k0, k1, k2, k3, after_smt_read, key, root_ptr, node_ptr_ptr, retdest
+    PUSH 0
+    DUP8
+    // stack: root_ptr, level, k0, k1, k2, k3, after_smt_read, key, root_ptr, node_ptr_ptr, retdest
+    %jump(smt_read)
+after_smt_read:
+    //stack: trie_value_ptr_ptr, key, root_ptr, node_ptr_ptr, retdest
+    DUP4
+    %add_const(2) // Get the initial value
+    MLOAD_GENERAL
+    SWAP1
+    %mstore_trie_data
+    // stack: key, root_ptr, node_ptr_ptr, retdest
+    POP
+    SWAP1
+    %next_initial_node
+    // stack: node_ptr_ptr', root_ptr, retdest
+    %jump(insert_all_initial_nodes)
+
+no_more_nodes:
+    // stack: key, root_ptr, node_ptr_ptr, retdest
+    %stack (key, root_ptr, node_ptr_ptr, retdest) ->(retdest, root_ptr)
+    JUMP
\ No newline at end of file
diff --git a/evm_arithmetization/src/cpu/kernel/asm/linked_list/type2/state_linked_list.asm b/evm_arithmetization/src/cpu/kernel/asm/linked_list/type2/state_linked_list.asm
new file mode 100644
index 000000000..90f59af37
--- /dev/null
+++ b/evm_arithmetization/src/cpu/kernel/asm/linked_list/type2/state_linked_list.asm
@@ -0,0 +1,486 @@
+/// The state linked list is stored in SEGMENT_ACCOUNTS_LINKED_LIST in the kernel memory (context=0). 
+/// The length of the segment is stored in @GLOBAL_METADATA_ACCOUNTS_LINKED_LIST_NEXT_AVAILABLE.
+/// Searching and inserting is done by guessing the predecessor in the list.
+/// If the key isn't found in the array, it is inserted 
+/// at the correct location. The linked list is used to keep track of
+/// inserted, modified and deleted accounts balances, nonces, storage, etc, during the execution, so that the 
+/// initial and final MPT state tries can be reconstructed at the end of the execution.
+/// An empty astate linked list is written as
+/// [@U256_MAX, _, _, @SEGMENT_ACCOUNTS_LINKED_LIST] in SEGMENT_ACCOUNTS_LINKED_LIST.
+/// Each node is encoded using 4 values:
+/// - 0: The key
+/// - 1: The value
+/// - 2: The initial value.
+/// - 3: A ptr (in segment @SEGMENT_ACCOUNTS_LINKED_LIST) to the next node in the list.
+
+%macro store_initial_state
+    PUSH %%after
+    %jump(store_initial_state)
+%%after:
+%endmacro
+
+
+/// Iterates over the initial state linked list and copies the values in the inital values slot.
+/// Computes the length of `SEGMENT_STORAGE_LINKED_LIST` and 
+/// checks against `GLOBAL_METADATA_STORAGE_LINKED_LIST_NEXT_AVAILABLE`.
+/// It also checks that the next node address is current address + 4
+/// and that all keys are strictly increasing.
+/// NOTE: It may be more efficient to check that the next node addres != U256_MAX
+/// (i.e. node was not deleted) and ensure that no node with repeated key
+/// is ever read.
+global store_initial_state:
+    // stack: retdest
+    PUSH @ACCOUNTS_LINKED_LISTS_NODE_SIZE
+    PUSH @SEGMENT_ACCOUNTS_LINKED_LIST
+    ADD
+    // stack: cur_len, retdest
+    PUSH @SEGMENT_ACCOUNTS_LINKED_LIST
+    DUP1
+    MLOAD_GENERAL
+    // stack: current_key, current_node_ptr, cur_len, retdest
+    %assert_eq_const(@U256_MAX)
+
+    // stack: current_node_ptr, cur_len', retdest
+    DUP1
+    %next_node
+    // stack: next_node_ptr, current_node_ptr, cur_len, retdest
+    DUP1
+    SWAP2
+    %next_initial_node
+    %assert_eq(store_initial_state_end) // next_node_ptr == current_node_ptr + node_size
+    // stack: next_node_ptr, cur_len', retdest
+ 
+loop_store_initial_state:
+    // stack: current_node_ptr, cur_len, retdest
+    DUP1
+    %increment
+    MLOAD_GENERAL
+    // stack: value, current_node_ptr, cur_len, retdest
+    DUP2
+    %add_const(@STATE_COPY_PAYLOAD_PTR)
+    // stack: cpy_value_ptr, value, current_node_ptr, cur_len, retdest
+    SWAP1
+    MSTORE_GENERAL // Store cpy_value
+    // stack: current_node_ptr, cur_len, retdest
+    SWAP1 PUSH @STATE_LINKED_LISTS_NODE_SIZE
+    ADD
+    SWAP1
+    // Check correctness of next node ptr and strict key monotonicity.
+    DUP1
+    MLOAD_GENERAL
+    // stack: current_key, current_node_ptr, cur_len', retdest
+    SWAP1
+    DUP1
+    %next_node
+    // stack: next_node_ptr, current_node_ptr, current_key, cur_len', retdest
+    DUP1
+    SWAP2
+    %next_initial_node
+    %assert_eq(store_initial_state_end_pop_key) // next_node_ptr ==  current_node_ptr + node_size
+    // stack: next_node_ptr, current_key, cur_len', retdest
+    SWAP1
+    DUP2
+    MLOAD_GENERAL
+    %assert_gt // next_key > current_key
+    // stack: next_node_ptr, cur_len', retdest
+    %jump(loop_store_initial_state)
+
+store_initial_state_end_pop_key:
+    // stack: next_node_ptr, current_key, cur_len', retdest
+    SWAP1 POP
+
+store_initial_state_end:
+    // stack: next_node_ptr, cur_len', retdest
+    %assert_eq_const(@SEGMENT_ACCOUNTS_LINKED_LIST)
+    
+    // stack: cur_len, retdest
+    DUP1
+    %mstore_global_metadata(@GLOBAL_METADATA_INITIAL_ACCOUNTS_LINKED_LIST_LEN)
+    %mstore_global_metadata(@GLOBAL_METADATA_ACCOUNTS_LINKED_LIST_NEXT_AVAILABLE)
+    JUMP
+
+
+// Multiplies the value at the top of the stack, denoted by ptr/4, by 4
+// and aborts if ptr/4 >= mem[@GLOBAL_METADATA_ACCOUNTS_LINKED_LIST_NEXT_AVAILABLE]/4.
+// Also checks that ptr >= @SEGMENT_ACCOUNTS_LINKED_LIST.
+// This way, 4*ptr/4 must be pointing to the beginning of a node.
+// TODO: Maybe we should check here if the node has been deleted.
+%macro get_valid_state_ptr
+    // stack: ptr/4
+    // Check that the pointer is greater than the segment.
+    PUSH @SEGMENT_ACCOUNTS_LINKED_LIST
+    DUP2
+    %mul_const(4)
+    // stack: ptr, @SEGMENT_ACCOUNTS_LINKED_LIST, ptr/4
+    %increment %assert_gt
+    // stack: ptr/4
+    DUP1
+    PUSH 4
+    %mload_global_metadata(@GLOBAL_METADATA_ACCOUNTS_LINKED_LIST_NEXT_AVAILABLE)
+    // By construction, both @SEGMENT_ACCOUNTS_LINKED_LIST and the unscaled list len
+    // must be multiples of 4
+    DIV
+    // stack: @SEGMENT_ACCOUNTS_LINKED_LIST/4 + accounts_linked_list_len/4, ptr/4, ptr/4
+    %assert_gt
+    %mul_const(4)
+%endmacro
+
+%macro set_nonce
+    // stack: address, nonce
+    %key_nonce
+    %insert_key
+    // stack: (empty)
+%endmacro
+
+%macro set_balance
+    // stack: address, balance
+    %key_balance
+    %insert_key
+    // stack: (empty)
+%endmacro
+
+%macro set_code
+    // stack: address, code
+    %key_code
+    %insert_key
+    // stack: (empty)
+%endmacro
+
+%macro set_code_length
+    // stack: address, code_lenght
+    %key_code_length
+    %insert_key
+    // stack: (empty)
+%endmacro
+
+
+%macro insert_slot
+    // stack: addr, slot, value
+    %key_storage
+    %insert_key
+    // stack: (empty)
+%endmacro
+
+%macro insert_slot_from_addr_key
+    // stack: addr_key, slot_key, value
+    %key_storage
+    %insert_key
+    // stack: (empty)
+%endmacro
+
+
+%macro insert_key
+    %stack (key, value) -> (key, value, %%after)
+    %jump(insert_key)
+    %%after:
+%endmacro
+
+/// Inserts the pair `(key, value)`  into the linked list if `key` was not already present,
+/// or modifies the vealue if it was already present.
+global insert_key:
+    // stack: key, value, retdest
+    DUP2 ISZERO %jumpi(insert_zero)
+    PROVER_INPUT(linked_list::insert_state)
+    // stack: pred_ptr/4, key, value, retdest
+    %get_valid_state_ptr
+
+    // stack: pred_ptr, key, value, retdest
+    DUP1
+    MLOAD_GENERAL
+    DUP1
+    // stack: pred_key, pred_key, pred_ptr, key, value, retdest
+    DUP4 
+    GT
+    DUP3 %eq_const(@SEGMENT_ACCOUNTS_LINKED_LIST)
+    ADD // OR
+    // If the predesessor is strictly smaller or the predecessor is the special
+    // node with key @U256_MAX (and hence we're inserting a new minimum), then
+    // we need to insert a new node.
+    %jumpi(insert_new_key)
+    // stack: pred_key, pred_ptr, key, value, retdest
+    // If we are here we know that addr <= pred_addr. But this is only possible if pred_addr == addr.
+    DUP3
+    %assert_eq
+    // stack: pred_ptr, key, value, retdest
+    // Check that this is not a deleted node
+    DUP1
+    %add_const(@ACCOUNTS_NEXT_NODE_PTR)
+    MLOAD_GENERAL
+    %jump_neq_const(@U256_MAX, key_found_with_overwrite)
+    // The key is not in the list.
+    PANIC
+
+insert_zero:
+    // stack: key, value, retdest
+    %remove_key
+    POP
+    JUMP
+
+key_found_with_overwrite:
+    // The key was already in the list
+    // stack: pred_ptr, key, value, retdest
+    // Load the payload pointer
+    %increment
+    // stack: payload_ptr_ptr, key, value, retdest
+    DUP3 MSTORE_GENERAL
+    %pop2
+    JUMP
+
+insert_new_key:
+    // stack: pred_key, pred_ptr, key, value, retdest
+    POP
+    // get the value of the next address
+    %add_const(@ACCOUNTS_NEXT_NODE_PTR)
+    // stack: next_ptr_ptr, key, value, retdest
+    %mload_global_metadata(@GLOBAL_METADATA_ACCOUNTS_LINKED_LIST_NEXT_AVAILABLE)
+    DUP2
+    MLOAD_GENERAL
+    // stack: next_ptr, new_ptr, next_ptr_ptr, key, value, retdest
+    // Check that this is not a deleted node
+    DUP1
+    %eq_const(@U256_MAX)
+    %assert_zero
+    DUP1
+    MLOAD_GENERAL
+    // stack: next_key, next_ptr, new_ptr, next_ptr_ptr, key, value, retdest
+    DUP5
+    // Here, (key > pred_key) || (pred_ptr == @SEGMENT_ACCOUNTS_LINKED_LIST).
+    // We should have (key < next_key), meaning the new value can be inserted between pred_ptr and next_ptr.
+    %assert_lt
+    // stack: next_ptr, new_ptr, next_ptr_ptr, key, value, retdest
+    SWAP2
+    DUP2
+    // stack: new_ptr, next_ptr_ptr, new_ptr, next_ptr, key, value, retdest
+    MSTORE_GENERAL
+    // stack: new_ptr, next_ptr, key, value, retdest
+    DUP1
+    DUP4
+    MSTORE_GENERAL
+    // stack: new_ptr, next_ptr, key, value, retdest
+    %increment
+    DUP1
+    DUP5
+    MSTORE_GENERAL
+    // stack: new_ptr + 1, next_ptr, key, value, retdest
+    %add_const(2) // TODO: We're skiping the initial value. This shuould also done with the accounts bc this value should't be used.
+    DUP1
+    // stack: new_next_ptr, new_next_ptr, next_ptr, key, value, retdest
+    SWAP2
+    MSTORE_GENERAL
+    // stack: new_next_ptr, key, value, retdest
+    %increment
+    %mstore_global_metadata(@GLOBAL_METADATA_ACCOUNTS_LINKED_LIST_NEXT_AVAILABLE)
+    // stack: key, value, retdest
+    %pop2
+    JUMP
+
+
+/// Searches the key in the state the linked list. If the key is stored
+/// returns the current value of the key, or 0 otherwise. 
+global search_key:
+    // stack: key, retdest
+    PROVER_INPUT(linked_list::search_state)
+    // stack: pred_ptr/4, key, retdest
+    %get_valid_state_ptr
+
+    // stack: pred_ptr, key, retdest
+    DUP1
+    MLOAD_GENERAL
+    DUP1
+    // stack: pred_key, pred_key, pred_ptr, key, retdest
+    DUP4 
+    GT
+    DUP3 %eq_const(@SEGMENT_ACCOUNTS_LINKED_LIST)
+    ADD // OR
+    // If the predesessor is strictly smaller or the predecessor is the special
+    // node with key @U256_MAX (and hence we're inserting a new minimum), then
+    // the key was not found.
+    %jumpi(key_not_found)
+    // stack: pred_key, pred_ptr, key, retdest
+    // If we are here we know that addr <= pred_addr. But this is only possible if pred_addr == addr.
+    DUP3
+    %assert_eq
+    // stack: pred_ptr, key, retdest
+    // Check that this is not a deleted node
+    DUP1
+    %add_const(@STATE_NEXT_NODE_PTR)
+    MLOAD_GENERAL
+    %jump_neq_const(@U256_MAX, key_found)
+    // The key is not in the list.
+    PANIC
+
+global key_found:
+    // The key was already in the list.
+    // stack: pred_ptr, key, retdest
+    %increment
+    MLOAD_GENERAL
+    // stack: value, key, retdest
+    %stack (value, key, retdest) -> (retdest, value)
+    JUMP
+
+key_not_found:
+    // stack: pred_key, pred_ptr, key, retdest
+    %stack (pred_key, pred_ptr, key, retdest) -> (retdest, 0)
+    JUMP
+
+%macro search_key
+    %stack (key) -> (key, %%after)
+    %jump(search_key)
+%%after:
+    // stack: value
+%endmacro
+%macro search_slot_from_addr_key
+    // stack: addr_key, slot
+    %key_storage
+    %search_key
+%endmacro
+
+%macro read_balance
+    // stack: addr_key
+    %key_balance
+    %search_key
+%endmacro
+
+%macro read_code
+    // stack: addr_key
+    %key_code
+    %search_key
+    // stack: code_hash
+%endmacro
+
+%macro read_code_length
+    // stack: addr_key
+    %key_code_length
+    %search_key
+    // stack: code_length
+%endmacro
+
+%macro read_nonce
+    // stack: addr_key
+    %key_nonce
+    %search_key
+    // stack: nonce
+%endmacro
+
+%macro remove_key
+    PUSH %%after
+    SWAP1
+    %jump(remove_key)
+%%after:
+%endmacro
+
+%macro remove_balance
+    %key_balance
+    %remove_key
+%endmacro
+
+%macro remove_slot_from_addr
+    %key_storage
+    %remove_key
+%endmacro
+
+/// Removes the key and its value from the state linked list.
+global remove_key:
+    // stack: key, retdest
+    PROVER_INPUT(linked_list::remove_state)
+    // stack: pred_ptr/4, key, retdest
+    %get_valid_state_ptr
+    // stack: pred_ptr, key, retdest
+    DUP1
+    %add_const(@STATE_NEXT_NODE_PTR)
+    // stack: next_ptr_ptr, pred_ptr, key, retdest
+    DUP1
+    MLOAD_GENERAL
+    // stack: next_ptr, next_ptr_ptr,  pred_ptr, key, retdest
+    DUP1
+    MLOAD_GENERAL
+    // stack: next_key, next_ptr, next_ptr_ptr, pred_ptr, key, retdest
+    DUP5
+    DUP2
+    %assert_eq(not_found)
+    POP
+    // stack: next_ptr, next_ptr_ptr, pred_ptr, key, retdest
+    %add_const(@STATE_NEXT_NODE_PTR)
+    // stack: next_next_ptr_ptr, next_ptr_ptr, pred_ptr, key, retdest
+    DUP1
+    MLOAD_GENERAL
+    // stack: next_next_ptr, next_next_ptr_ptr, next_ptr_ptr, pred_ptr, key, retdest
+    SWAP1
+    %mstore_u256_max
+    // stack: next_next_ptr, next_ptr_ptr, pred_ptr, key, retdest
+    MSTORE_GENERAL
+    %pop2
+    JUMP
+not_found:
+     // stack: next_key, next_ptr, next_ptr_ptr, pred_ptr, key, retdest
+     DUP5
+     %assert_lt
+     // stack: next_ptr, next_ptr_ptr, pred_ptr, key, retdest
+     %pop2
+     MLOAD_GENERAL
+     // stack: prev_key, key, retdest
+     SWAP1
+     DUP2
+     LT
+     // prev_key < key, prev_key, retdest
+     SWAP1
+     %eq_const(@U256_MAX)
+     ADD
+     %assert_nonzero
+     JUMP
+
+%macro read_slot_from_current_addr
+    // stack: slot
+    %address
+    %key_storage
+    %stack (storage_key) -> (storage_key, %%after)
+    // stack: storage_key, %%after
+    %jump(search_key)
+%%after:
+    // stack: slot_value
+%endmacro
+
+%macro read_slot_from_addr_key
+    // stack: state_key, slot
+    %key_storage
+    %stack (storage_key) -> (storage_key, %%after)
+    %jump(search_key)
+%%after:
+    // stack: slot_value
+%endmacro
+
+%macro read_slot_from_addr
+    // stack: address, slot
+    // %addr_to_state_key
+    %key_storage
+    %stack (storage_key) -> (storage_key, %%after)
+    // stack: storage_key, %%after
+    %jump(search_key)
+%%after:
+    // stack: slot_value
+%endmacro
+
+%macro first_node
+    // stack: empty
+    PUSH @SEGMENT_ACCOUNTS_LINKED_LIST
+    %next_node
+%endmacro
+
+%macro first_initial_node
+    // stack: empty
+    PUSH @SEGMENT_ACCOUNTS_LINKED_LIST
+    %next_initial_node
+%endmacro
+
+%macro next_node
+    // stack: node_ptr
+    %add_const(@ACCOUNTS_NEXT_NODE_PTR)
+    MLOAD_GENERAL
+    // stack: next_node_ptr
+%endmacro
+
+%macro next_initial_node
+    // stack: node_ptr
+    %add_const(@ACCOUNTS_LINKED_LISTS_NODE_SIZE)
+    // stack: next_node_ptr
+%endmacro
\ No newline at end of file
diff --git a/evm_arithmetization/src/cpu/kernel/asm/main.asm b/evm_arithmetization/src/cpu/kernel/asm/main.asm
index cb170ef24..1e7643f1b 100644
--- a/evm_arithmetization/src/cpu/kernel/asm/main.asm
+++ b/evm_arithmetization/src/cpu/kernel/asm/main.asm
@@ -76,8 +76,7 @@ global main:
 
 global store_initial:
     // Store the initial accounts and slots for hashing later
-    %store_initial_accounts
-    %store_initial_slots
+    %store_initial_state
    
 global after_store_initial:
     // Initialize the transaction and receipt trie root pointers.
@@ -89,20 +88,28 @@ global after_store_initial:
 global hash_initial_tries:
     // We compute the length of the trie data segment in `mpt_hash` so that we
     // can check the value provided by the prover.
-    // The trie data segment is already written by the linked lists
 
-    // First, we compute the initial size of the trie data segment.
-    PUSH @ACCOUNTS_LINKED_LISTS_NODE_SIZE
-    PUSH @SEGMENT_ACCOUNTS_LINKED_LIST
-    %mload_global_metadata(@GLOBAL_METADATA_ACCOUNTS_LINKED_LIST_NEXT_AVAILABLE)
-    SUB
-    // stack: accounts_ll_full_len, accounts_ll_node_size
-    DIV
-    %decrement
-    // stack: actual_nb_accounts
-    // The initial payloads are written twice, and each payload requires 4 elements.
-    PUSH 8 MUL
-    %increment
+    #[cfg(not(feature = cdk_erigon))]
+    {
+        // First, we compute the initial size of the trie data segment.
+        PUSH @ACCOUNTS_LINKED_LISTS_NODE_SIZE
+        PUSH @SEGMENT_ACCOUNTS_LINKED_LIST
+        %mload_global_metadata(@GLOBAL_METADATA_ACCOUNTS_LINKED_LIST_NEXT_AVAILABLE)
+        SUB
+        // stack: accounts_ll_full_len, accounts_ll_node_size
+        DIV
+        %decrement
+        // stack: actual_nb_accounts
+        // The initial payloads are written twice, and each payload requires 4 elements.
+        PUSH 8 MUL
+        %increment
+    }
+    #[cfg(feature = cdk_erigon)]
+    {
+        // The trie data segment contains only the empty node
+        PUSH 2
+    }
+    global debug_init_trie_data_len:
     // stack: init_trie_data_len
     PUSH @INITIAL_RLP_ADDR
     // stack: rlp_start, init_trie_data_len
@@ -113,6 +120,7 @@ global hash_initial_tries:
     // stack: trie_data_full_len
     // Check that the trie data length is correct.
     %mload_global_metadata(@GLOBAL_METADATA_TRIE_DATA_SIZE)
+global debug_asdasdasd:
     %assert_eq
 
 global start_txns:
@@ -137,7 +145,7 @@ global start_txns:
     #[cfg(feature = cdk_erigon)]
     {
         // If txn_idx == 0, perform pre-state execution for CDK erigon.
-        DUP4
+        %mload_global_metadata(@GLOBAL_METADATA_TXN_NUMBER_BEFORE)
         ISZERO
         %jumpi(pre_block_execution)
     }
@@ -188,7 +196,8 @@ global txn_loop_after:
 global perform_final_checks:
     // stack: cum_gas, txn_counter, num_nibbles, txn_nb
     // Check that we end up with the correct `cum_gas`, `txn_nb` and bloom filter.
-    %mload_global_metadata(@GLOBAL_METADATA_BLOCK_GAS_USED_AFTER) %assert_eq
+    %mload_global_metadata(@GLOBAL_METADATA_BLOCK_GAS_USED_AFTER)
+    %assert_eq
     DUP3
     %mload_global_metadata(@GLOBAL_METADATA_TXN_NUMBER_AFTER) %assert_eq
     %pop3
@@ -226,9 +235,7 @@ global check_state_trie:
     %set_initial_state_trie
     // stack: trie_data_len
 
-    PUSH @INITIAL_RLP_ADDR
-    // stack: rlp_start, trie_data_len
-    %mpt_hash_state_trie
+    %hash_state_trie
 
     // stack: init_state_hash, trie_data_len
     // Check that the initial trie is correct.
@@ -243,9 +250,10 @@ global check_state_trie:
     PUSH 1
 global check_final_state_trie:
     %set_final_tries
-    PUSH @INITIAL_RLP_ADDR
-    // stack: rlp_start, dummy_trie_len
-    %mpt_hash_state_trie   %mload_global_metadata(@GLOBAL_METADATA_STATE_TRIE_DIGEST_AFTER)     %assert_eq
+
+    %hash_state_trie
+    %mload_global_metadata(@GLOBAL_METADATA_STATE_TRIE_DIGEST_AFTER)
+    %assert_eq
     // We don't need the trie data length here.
     POP
 
diff --git a/evm_arithmetization/src/cpu/kernel/asm/mpt/delete/delete.asm b/evm_arithmetization/src/cpu/kernel/asm/mpt/delete/delete.asm
index c878ae812..9c9a206c2 100644
--- a/evm_arithmetization/src/cpu/kernel/asm/mpt/delete/delete.asm
+++ b/evm_arithmetization/src/cpu/kernel/asm/mpt/delete/delete.asm
@@ -23,19 +23,22 @@ mpt_delete_leaf:
     PUSH 0 // empty node ptr
     SWAP1 JUMP
 
-global delete_account:
-    %addr_to_state_key
-    DUP1
-    %remove_account_from_linked_list
-    // stack: addr_to_state_key, retdest
+#[cfg(not(feature = cdk_erigon))]
+{
+    global delete_account:
+        %addr_to_state_key
+        DUP1
+        %remove_account_from_linked_list
+        // stack: addr_to_state_key, retdest
 
-    // Now we also need to remove all the storage nodes associated with the deleted account.
-    %remove_all_account_slots
-    JUMP
+        // Now we also need to remove all the storage nodes associated with the deleted account.
+        %remove_all_account_slots
+        JUMP
 
-%macro delete_account
-    %stack (address) -> (address, %%after)
-    %jump(delete_account)
-%%after:
-    // stack: (empty)
-%endmacro
+    %macro delete_account
+        %stack (address) -> (address, %%after)
+        %jump(delete_account)
+    %%after:
+        // stack: (empty)
+    %endmacro
+}
diff --git a/evm_arithmetization/src/cpu/kernel/asm/mpt/hash/hash_trie_specific.asm b/evm_arithmetization/src/cpu/kernel/asm/mpt/hash/hash_trie_specific.asm
index 31fa192fa..129c3b97f 100644
--- a/evm_arithmetization/src/cpu/kernel/asm/mpt/hash/hash_trie_specific.asm
+++ b/evm_arithmetization/src/cpu/kernel/asm/mpt/hash/hash_trie_specific.asm
@@ -1,5 +1,15 @@
 // Hashing logic specific to a particular trie.
 
+#[cfg(not(feature = cdk_erigon))]
+{
+    %macro hash_state_trie
+        // stack: trie_len
+        PUSH @INITIAL_RLP_ADDR
+        // stack: rlp_start, dummy_trie_len
+        %mpt_hash_state_trie
+    %endmacro
+}
+
 global mpt_hash_state_trie:
     // stack: rlp_start, cur_len, retdest
     PUSH encode_account
@@ -78,6 +88,7 @@ global encode_account:
     // Now, we start the encoding.
     // stack: rlp_addr, value_ptr, cur_len, retdest
     DUP2 %mload_trie_data // nonce = value[0]
+global debug_the_nonce:
     %rlp_scalar_len
     // stack: nonce_rlp_len, rlp_addr, value_ptr, cur_len, retdest
     DUP3 %increment %mload_trie_data // balance = value[1]
@@ -112,6 +123,7 @@ global encode_account:
 
     // Hash storage trie.
     %mpt_hash_storage_trie
+global debug_storage_hash:
     // stack: storage_root_digest, new_len, rlp_pos_5, value_ptr, cur_len, retdest
     %stack(storage_root_digest, new_len, rlp_pos_five, value_ptr, cur_len) -> (rlp_pos_five, storage_root_digest, value_ptr, new_len)
     %encode_rlp_256
diff --git a/evm_arithmetization/src/cpu/kernel/asm/mpt/insert/insert_trie_specific.asm b/evm_arithmetization/src/cpu/kernel/asm/mpt/insert/insert_trie_specific.asm
index e4e6061e4..03fbce3f2 100644
--- a/evm_arithmetization/src/cpu/kernel/asm/mpt/insert/insert_trie_specific.asm
+++ b/evm_arithmetization/src/cpu/kernel/asm/mpt/insert/insert_trie_specific.asm
@@ -4,16 +4,21 @@
 // Pre stack: key, value_ptr, retdest
 // Post stack: (empty)
 // TODO: Have this take an address and do %mpt_insert_state_trie? To match mpt_read_state_trie.
-global mpt_insert_state_trie:
-    // stack: key, value_ptr, retdest
-    %insert_account_with_overwrite
-    JUMP
+#[cfg(not(feature = cdk_erigon))]
+{
+    global mpt_insert_state_trie:
+        // stack: key, value_ptr, retdest
+        %insert_account_with_overwrite
+        JUMP
 
-%macro mpt_insert_state_trie
-    %stack (key, value_ptr) -> (key, value_ptr, %%after)
-    %jump(mpt_insert_state_trie)
-%%after:
-%endmacro
+
+    %macro mpt_insert_state_trie
+        %stack (key, value_ptr) -> (key, value_ptr, %%after)
+        %jump(mpt_insert_state_trie)
+    %%after:
+    %endmacro
+
+}
 
 // Insert a node in the transaction trie. The payload
 // must be pointing to the rlp encoded txn
diff --git a/evm_arithmetization/src/cpu/kernel/asm/mpt/linked_list/linked_list.asm b/evm_arithmetization/src/cpu/kernel/asm/mpt/linked_list/linked_list.asm
deleted file mode 100644
index 650d69db2..000000000
--- a/evm_arithmetization/src/cpu/kernel/asm/mpt/linked_list/linked_list.asm
+++ /dev/null
@@ -1,1056 +0,0 @@
-/// Linked lists for accounts and storage slots.
-/// The accounts linked list is stored in SEGMENT_ACCOUNTS_LINKED_LIST while the slots 
-/// are stored in SEGMENT_STORAGE_LINKED_LIST. The length of
-/// the segments is stored in the associated global metadata.
-/// Both arrays are stored in the kernel memory (context=0).
-/// Searching and inserting is done by guessing the predecessor in the list.
-/// If the address/storage key isn't found in the array, it is inserted 
-/// at the correct location. These linked lists are used to keep track of
-/// inserted and deleted accounts/slots during the execution, so that the 
-/// initial and final MPT state tries can be reconstructed at the end of the execution.
-/// An empty account linked list is written as
-/// [@U256_MAX, _, _, @SEGMENT_ACCOUNTS_LINKED_LIST] in SEGMENT_ACCOUNTS_LINKED_LIST.
-/// The linked list is preinitialized by appending accounts to the segment. Each account is encoded
-/// using 4 values.
-/// The values at the respective positions are:
-/// - 0: The account key
-/// - 1: A ptr to the payload (the account values)
-/// - 2: A ptr to the initial payload.
-/// - 3: A ptr (in segment @SEGMENT_ACCOUNTS_LINKED_LIST) to the next node in the list.
-/// Similarly, an empty storage linked list is written as
-/// [@U256_MAX, _, _, _, @SEGMENT_ACCOUNTS_LINKED_LIST] in SEGMENT_ACCOUNTS_LINKED_LIST.
-/// The linked list is preinitialized by appending storage slots to the segment. 
-/// Each slot is encoded using 5 values.
-/// The values at the respective positions are:
-/// - 0: The account key
-/// - 1: The slot key
-/// - 2: The slot value.
-/// - 3: The initial slot value.
-/// - 4: A ptr (in segment @SEGMENT_ACCOUNTS_LINKED_LIST) to the next node in the list.
-
-%macro store_initial_accounts
-    PUSH %%after
-    %jump(store_initial_accounts)
-%%after:
-%endmacro
-
-/// Iterates over the initial account linked list and shallow copies
-/// the accounts, storing a pointer to the copied account in the node.
-/// Computes the length of `SEGMENT_ACCOUNTS_LINKED_LIST` and 
-/// stores it in `GLOBAL_METADATA_ACCOUNTS_LINKED_LIST_NEXT_AVAILABLE`.
-/// It also checks that the next node address is current address + 4
-/// and that all keys are strictly increasing.
-/// NOTE: It may be more efficient to check that the next node addres != U256_MAX
-/// (i.e. node was not deleted) and ensure that no node with repeated key
-/// is ever read.
-global store_initial_accounts:
-    // stack: retdest
-    PUSH @ACCOUNTS_LINKED_LISTS_NODE_SIZE
-    PUSH @SEGMENT_ACCOUNTS_LINKED_LIST
-    ADD
-    // stack: cur_len, retdest
-    PUSH @SEGMENT_ACCOUNTS_LINKED_LIST
-    // stack: current_node_ptr, cur_len, retdest
-    DUP1
-    MLOAD_GENERAL
-    // stack: current_addr_key, current_node_ptr, cur_len', retdest
-    %assert_eq_const(@U256_MAX)
-    DUP1
-    %next_account
-    // stack: next_node_ptr, current_node_ptr, cur_len', retdest
-    DUP1
-    SWAP2
-    %next_initial_account
-    %assert_eq(store_initial_accounts_end) // next_node_ptr ==  current_node_ptr + node_size
-    // stack: next_node_ptr, cur_len', retdest
-    
-loop_store_initial_accounts:
-    // stack: current_node_ptr, cur_len, retdest
-    %get_trie_data_size
-    // stack: cpy_ptr, current_node_ptr, cur_len, retdest
-    DUP2
-    %increment
-    MLOAD_GENERAL
-    // stack: nonce_ptr, cpy_ptr, current_node_ptr, cur_len, retdest
-    DUP1
-    %mload_trie_data // nonce
-    %append_to_trie_data
-    %increment
-    // stack: balance_ptr, cpy_ptr, current_node_ptr, cur_len, retdest
-    DUP1
-    %mload_trie_data // balance
-    %append_to_trie_data
-    %increment // The storage_root_ptr is not really necessary
-    // stack: storage_root_ptr_ptr, cpy_ptr, current_node_ptr, cur_len, retdest
-    DUP1
-    %mload_trie_data // storage_root_ptr
-    %append_to_trie_data
-    %increment
-    // stack: code_hash_ptr, cpy_ptr, current_node_ptr, cur_len, retdest
-    %mload_trie_data // code_hash
-    %append_to_trie_data
-    // stack: cpy_ptr, current_node_ptr, cur_len, retdest
-    DUP2
-    %add_const(2)
-    SWAP1
-    MSTORE_GENERAL // Store cpy_ptr
-    // stack: current_node_ptr, cur_len, retdest
-    SWAP1 PUSH @ACCOUNTS_LINKED_LISTS_NODE_SIZE 
-    ADD
-    SWAP1
-    // Check next node ptr validity and strict keys monotonicity
-    DUP1
-    MLOAD_GENERAL
-    // stack: current_addr_key, current_node_ptr, cur_len', retdest
-    SWAP1
-    DUP1
-    %next_account
-    // stack: next_node_ptr, current_node_ptr, current_addr_key, cur_len', retdest
-    DUP1
-    SWAP2
-    %next_initial_account
-    %assert_eq(store_initial_accounts_end_pop_key) // next_node_ptr ==  current_node_ptr + node_size
-    // stack: next_node_ptr, current_addr_key, cur_len', retdest
-    SWAP1
-    DUP2
-    MLOAD_GENERAL
-    %assert_gt // next_addr_key > current_addr_key
-    // stack: next_node_ptr, cur_len', retdest
-    %jump(loop_store_initial_accounts)
-
-store_initial_accounts_end_pop_key:
-    // stack: next_node_ptr, current_addr_key, cur_len', retdest
-    SWAP1 POP
-store_initial_accounts_end:
-    // stack: next_node_ptr, cur_len', retdest
-    %assert_eq_const(@SEGMENT_ACCOUNTS_LINKED_LIST)
-    // stack: cur_len, retdest
-    DUP1
-    %mstore_global_metadata(@GLOBAL_METADATA_INITIAL_ACCOUNTS_LINKED_LIST_LEN)
-    %mstore_global_metadata(@GLOBAL_METADATA_ACCOUNTS_LINKED_LIST_NEXT_AVAILABLE)
-    JUMP
-
-%macro insert_account_with_overwrite
-    %stack (addr_key, ptr) -> (addr_key, ptr, %%after)
-    %jump(insert_account_with_overwrite)
-%%after:
-%endmacro
-
-// Multiplies the value at the top of the stack, denoted by ptr/4, by 4
-// and aborts if ptr/4 <= mem[@GLOBAL_METADATA_ACCOUNTS_LINKED_LIST_NEXT_AVAILABLE]/4.
-// Also checks that ptr >= @SEGMENT_ACCOUNTS_LINKED_LIST.
-// This way, 4*ptr/4 must be pointing to the beginning of a node.
-// TODO: Maybe we should check here if the node has been deleted.
-%macro get_valid_account_ptr
-    // stack: ptr/4
-    // Check that the pointer is greater than the segment.
-    PUSH @SEGMENT_ACCOUNTS_LINKED_LIST
-    DUP2
-    %mul_const(4)
-    // stack: ptr, @SEGMENT_ACCOUNTS_LINKED_LIST, ptr/4
-    %increment %assert_gt
-    // stack: ptr/4
-    DUP1
-    PUSH 4
-    %mload_global_metadata(@GLOBAL_METADATA_ACCOUNTS_LINKED_LIST_NEXT_AVAILABLE)
-    // By construction, both @SEGMENT_ACCOUNTS_LINKED_LIST and the unscaled list len
-    // must be multiples of 4
-    DIV
-    // stack: @SEGMENT_ACCOUNTS_LINKED_LIST/4 + accounts_linked_list_len/4, ptr/4, ptr/4
-    %assert_gt
-    %mul_const(4)
-%endmacro
-
-global insert_account_with_overwrite:
-    // stack: addr_key, payload_ptr, retdest
-    PROVER_INPUT(linked_list::insert_account)
-    // stack: pred_ptr/4, addr_key, payload_ptr, retdest
-    %get_valid_account_ptr
-    // stack: pred_ptr, addr_key, payload_ptr, retdest
-    DUP1
-    MLOAD_GENERAL
-    DUP1
-    // stack: pred_addr_key, pred_addr_key, pred_ptr, addr_key, payload_ptr, retdest
-    DUP4 GT
-    DUP3 %eq_const(@SEGMENT_ACCOUNTS_LINKED_LIST)
-    ADD // OR
-    // If the predesessor is strictly smaller or the predecessor is the special
-    // node with key @U256_MAX (and hence we're inserting a new minimum), then
-    // we need to insert a new node.
-    %jumpi(insert_new_account)
-    // stack: pred_addr_key, pred_ptr, addr_key, payload_ptr, retdest
-    // If we are here we know that addr <= pred_addr. But this is only possible if pred_addr == addr.
-    DUP3
-    %assert_eq
-    
-    // stack: pred_ptr, addr_key, payload_ptr, retdest
-    // Check that this is not a deleted node
-    DUP1
-    %add_const(@ACCOUNTS_NEXT_NODE_PTR)
-    MLOAD_GENERAL
-    %jump_neq_const(@U256_MAX, account_found_with_overwrite)
-    // The storage key is not in the list.
-    PANIC
-
-account_found_with_overwrite:
-    // The address was already in the list
-    // stack: pred_ptr, addr_key, payload_ptr, retdest
-    // Load the payload pointer
-    %increment
-    // stack: payload_ptr_ptr, addr_key, payload_ptr, retdest
-    DUP3 MSTORE_GENERAL
-    %pop2
-    JUMP
-
-insert_new_account:
-    // stack: pred_addr_key, pred_ptr, addr_key, payload_ptr, retdest
-    POP
-    // get the value of the next address
-    %add_const(@ACCOUNTS_NEXT_NODE_PTR)
-    // stack: next_ptr_ptr, addr_key, payload_ptr, retdest
-    %mload_global_metadata(@GLOBAL_METADATA_ACCOUNTS_LINKED_LIST_NEXT_AVAILABLE)
-    DUP2
-    MLOAD_GENERAL
-    // stack: next_ptr, new_ptr, next_ptr_ptr, addr_key, payload_ptr, retdest
-    // Check that this is not a deleted node
-    DUP1
-    %eq_const(@U256_MAX)
-    %assert_zero
-    DUP1
-    MLOAD_GENERAL
-    // stack: next_addr_key, next_ptr, new_ptr, next_ptr_ptr, addr_key, payload_ptr, retdest
-    DUP5
-    // Here, (addr_key > pred_addr_key) || (pred_ptr == @SEGMENT_ACCOUNTS_LINKED_LIST).
-    // We should have (addr_key < next_addr_key), meaning the new value can be inserted between pred_ptr and next_ptr.
-    %assert_lt
-    // stack: next_ptr, new_ptr, next_ptr_ptr, addr_key, payload_ptr, retdest
-    SWAP2
-    DUP2
-    // stack: new_ptr, next_ptr_ptr, new_ptr, next_ptr, addr_key, payload_ptr, retdest
-    MSTORE_GENERAL
-    // stack: new_ptr, next_ptr, addr_key, payload_ptr, retdest
-    DUP1
-    DUP4
-    MSTORE_GENERAL
-    // stack: new_ptr, next_ptr, addr_key, payload_ptr, retdest
-    %increment
-    DUP1
-    DUP5
-    MSTORE_GENERAL
-    // stack: new_ptr + 1, next_ptr, addr_key, payload_ptr, retdest
-    %increment
-    DUP1
-    DUP5
-    %clone_account
-    MSTORE_GENERAL
-    %increment
-    DUP1
-    // stack: new_next_ptr, new_next_ptr, next_ptr, addr_key, payload_ptr, retdest
-    SWAP2
-    MSTORE_GENERAL
-    // stack: new_next_ptr, addr_key, payload_ptr, retdest
-    %increment
-    %mstore_global_metadata(@GLOBAL_METADATA_ACCOUNTS_LINKED_LIST_NEXT_AVAILABLE)
-    // stack: addr_key, payload_ptr, retdest
-    %pop2
-    JUMP
-
-
-/// Searches the account addr in the linked list.
-/// Returns 0 if the account was not found or `original_ptr` if it was already present.
-global search_account:
-    // stack: addr_key, retdest
-    PROVER_INPUT(linked_list::search_account)
-    // stack: pred_ptr/4, addr_key, retdest
-    %get_valid_account_ptr
-    // stack: pred_ptr, addr_key, retdest
-    DUP1
-    MLOAD_GENERAL
-    DUP1
-    // stack: pred_addr_key, pred_addr_key, pred_ptr, addr_key, retdest
-    DUP4 GT
-    DUP3 %eq_const(@SEGMENT_ACCOUNTS_LINKED_LIST)
-    ADD // OR
-    // If the predesessor is strictly smaller or the predecessor is the special
-    // node with key @U256_MAX (and hence we're inserting a new minimum), then
-    // we need to insert a new node.
-    %jumpi(account_not_found)
-    // stack: pred_addr_key, pred_ptr, addr_key, retdest
-    // If we are here we know that addr_key <= pred_addr_key. But this is only possible if pred_addr == addr.
-    DUP3
-    %assert_eq
-    
-    // stack: pred_ptr, addr_key, retdest
-    // Check that this is not a deleted node
-    DUP1
-    %add_const(@ACCOUNTS_NEXT_NODE_PTR)
-    MLOAD_GENERAL
-    %jump_neq_const(@U256_MAX, account_found)
-    // The storage key is not in the list.
-    PANIC
-
-account_found:
-    // The address was already in the list
-    // stack: pred_ptr, addr_key, retdest
-    // Load the payload pointer
-    %increment
-    MLOAD_GENERAL
-    // stack: orig_payload_ptr, addr_key, retdest
-    %stack (orig_payload_ptr, addr_key, retdest) -> (retdest, orig_payload_ptr)
-    JUMP
-
-account_not_found:
-    // stack: pred_addr_key, pred_ptr, addr_key, retdest
-    %stack (pred_addr_key, pred_ptr, addr_key, retdest) -> (retdest, 0)
-    JUMP
-
-%macro remove_account_from_linked_list
-    PUSH %%after
-    SWAP1
-    %jump(remove_account)
-%%after:
-%endmacro
-
-/// Removes the address and its value from the access list.
-/// Panics if the key is not in the list.
-global remove_account:
-    // stack: addr_key, retdest
-    PROVER_INPUT(linked_list::remove_account)
-    // stack: pred_ptr/4, addr_key, retdest
-    %get_valid_account_ptr
-    // stack: pred_ptr, addr_key, retdest
-    %add_const(@ACCOUNTS_NEXT_NODE_PTR)
-    // stack: next_ptr_ptr, addr_key, retdest
-    DUP1
-    MLOAD_GENERAL
-    // stack: next_ptr, next_ptr_ptr, addr_key, retdest
-    DUP1
-    MLOAD_GENERAL
-    // stack: next_addr_key, next_ptr, next_ptr_ptr, addr_key, retdest
-    DUP4
-    %assert_eq
-    // stack: next_ptr, next_ptr_ptr, addr_key, retdest
-    %add_const(@ACCOUNTS_NEXT_NODE_PTR)
-    // stack: next_next_ptr_ptr, next_ptr_ptr, addr_key, key, retdest
-    DUP1
-    MLOAD_GENERAL
-    // stack: next_next_ptr, next_next_ptr_ptr, next_ptr_ptr, addr_key, retdest
-    SWAP1
-    %mstore_u256_max
-    // stack: next_next_ptr, next_ptr_ptr, addr_key, retdest
-    MSTORE_GENERAL
-    POP
-    JUMP
-
-
-//
-//
-// STORAGE linked list
-//
-//
-
-%macro store_initial_slots
-    PUSH %%after
-    %jump(store_initial_slots)
-%%after:
-%endmacro
-
-
-/// Iterates over the initial account linked list and shallow copies
-/// the accounts, storing a pointer to the copied account in the node.
-/// Computes the length of `SEGMENT_STORAGE_LINKED_LIST` and 
-/// checks against `GLOBAL_METADATA_STORAGE_LINKED_LIST_NEXT_AVAILABLE`.
-/// It also checks that the next node address is current address + 5
-/// and that all keys are strictly increasing.
-/// NOTE: It may be more efficient to check that the next node addres != U256_MAX
-/// (i.e. node was not deleted) and ensure that no node with repeated key
-/// is ever read.
-global store_initial_slots:
-    // stack: retdest
-    PUSH @STORAGE_LINKED_LISTS_NODE_SIZE
-    PUSH @SEGMENT_STORAGE_LINKED_LIST
-    ADD
-    // stack: cur_len, retdest
-    PUSH @SEGMENT_STORAGE_LINKED_LIST
-    DUP1
-    MLOAD_GENERAL
-    // stack: current_addr_key, current_node_ptr, cur_len, retdest
-    %assert_eq_const(@U256_MAX)
-
-    // stack: current_node_ptr, cur_len', retdest
-    DUP1
-    %next_slot
-    // stack: next_node_ptr, current_node_ptr, cur_len, retdest
-    DUP1
-    SWAP2
-    %next_initial_slot
-    %assert_eq(store_initial_slots_end) // next_node_ptr == current_node_ptr + node_size
-    // stack: next_node_ptr, cur_len', retdest
- 
-loop_store_initial_slots:
-    // stack: current_node_ptr, cur_len, retdest
-    DUP1
-    %add_const(2)
-    MLOAD_GENERAL
-    // stack: value, current_node_ptr, cur_len, retdest
-    DUP2
-    %add_const(@STORAGE_COPY_PAYLOAD_PTR)
-    // stack: cpy_value_ptr, value, current_node_ptr, cur_len, retdest
-    SWAP1
-    MSTORE_GENERAL // Store cpy_value
-    // stack: current_node_ptr, cur_len, retdest
-    SWAP1 PUSH @STORAGE_LINKED_LISTS_NODE_SIZE
-    ADD
-    SWAP1
-    // Check correctness of next node ptr and strict key monotonicity.
-    DUP1
-    MLOAD_GENERAL
-    // stack: current_addr_key, current_node_ptr, cur_len', retdest
-    SWAP1
-    DUP1
-    %increment
-    MLOAD_GENERAL
-    // stack: current_slot_key, current_node_ptr, current_addr_key, cur_len', retdest
-    SWAP1
-    DUP1
-    %next_slot
-    // stack: next_node_ptr, current_node_ptr, current_slot_key, current_addr_key, cur_len', retdest
-    DUP1
-    SWAP2
-    %next_initial_slot
-    %assert_eq(store_initial_slots_end_pop_keys) // next_node_ptr == current_node_ptr + node_size
-    // stack: next_node_ptr, current_slot_key, current_addr_key, cur_len', retdest
-    DUP1
-    DUP1
-    %increment
-    MLOAD_GENERAL
-    // stack: next_node_slot_key, next_node_ptr, next_node_ptr, current_slot_key, current_addr_key, cur_len', retdest
-    SWAP1
-    MLOAD_GENERAL
-    // stack: next_node_addr_key, next_node_slot_key, next_node_ptr, current_slot_key, current_addr_key, cur_len', retdest
-    SWAP3
-    LT
-    // stack: current_slot_key > next_node_slot_key, next_node_ptr, next_node_addr_key, current_addr_key, cur_len', retdest
-    SWAP2
-    SWAP1
-    SWAP3
-    // stack: current_addr_key, next_node_addr_key, current_slot_key > next_node_slot_key, next_node_ptr, cur_len', retdest
-    DUP2
-    DUP2
-    EQ
-    // stack: current_addr_key == next_node_addr_key, current_addr_key, next_node_addr_key, current_slot_key > next_node_slot_key, next_node_ptr, cur_len', retdest
-    SWAP1
-    SWAP3
-    MUL // AND
-    // stack  current_slot_key > next_node_slot_key AND current_addr_key == next_node_addr_key, next_node_addr_key, current_addr_key, next_node_ptr, cur_len', retdest
-    SWAP2
-    LT
-    ADD // OR
-    %assert_nonzero
-    %jump(loop_store_initial_slots)
-
-store_initial_slots_end_pop_keys:
-    // stack: next_node_ptr, current_slot_key, current_addr_key, cur_len', retdest
-    SWAP2
-    %pop2
-
-store_initial_slots_end:
-    // stack: next_node_ptr, cur_len', retdest
-    %assert_eq_const(@SEGMENT_STORAGE_LINKED_LIST)
-    
-    // stack: cur_len, retdest
-    DUP1
-    %mstore_global_metadata(@GLOBAL_METADATA_INITIAL_STORAGE_LINKED_LIST_LEN)
-    %mstore_global_metadata(@GLOBAL_METADATA_STORAGE_LINKED_LIST_NEXT_AVAILABLE)
-    JUMP
-
-
-// Multiplies the value at the top of the stack, denoted by ptr/5, by 5
-// and aborts if ptr/5 >= (mem[@GLOBAL_METADATA_ACCOUNTS_LINKED_LIST_NEXT_AVAILABLE] - @SEGMENT_STORAGE_LINKED_LIST)/5.
-// This way, @SEGMENT_STORAGE_LINKED_LIST + 5*ptr/5 must be pointing to the beginning of a node.
-// TODO: Maybe we should check here if the node has been deleted.
-%macro get_valid_slot_ptr
-    // stack: ptr/5
-    DUP1
-    PUSH 5
-    PUSH @SEGMENT_STORAGE_LINKED_LIST
-    // stack: segment, 5, ptr/5, ptr/5
-    %mload_global_metadata(@GLOBAL_METADATA_STORAGE_LINKED_LIST_NEXT_AVAILABLE)
-    SUB
-    // stack: accessed_strg_keys_len, 5, ptr/5, ptr/5
-    // By construction, the unscaled list len must be multiple of 5
-    DIV
-    // stack: accessed_strg_keys_len/5, ptr/5, ptr/5
-    %assert_gt
-    %mul_const(5)
-    %add_const(@SEGMENT_STORAGE_LINKED_LIST)
-%endmacro
-
-/// Inserts the pair (address_key, storage_key) and a new payload pointer into the linked list if it is not already present,
-/// or modifies its payload if it was already present.
-global insert_slot_with_value:
-    // stack: addr_key, key, value, retdest
-    PROVER_INPUT(linked_list::insert_slot)
-    // stack: pred_ptr/5, addr_key, key, value, retdest
-    %get_valid_slot_ptr
-
-    // stack: pred_ptr, addr_key, key, value, retdest
-    DUP1
-    MLOAD_GENERAL
-    DUP1
-    // stack: pred_addr_key, pred_addr_key, pred_ptr, addr_key, key, value, retdest
-    DUP4 
-    GT
-    DUP3 %eq_const(@SEGMENT_STORAGE_LINKED_LIST)
-    ADD // OR
-    // If the predesessor is strictly smaller or the predecessor is the special
-    // node with key @U256_MAX (and hence we're inserting a new minimum), then
-    // we need to insert a new node.
-    %jumpi(insert_new_slot_with_value)
-    // stack: pred_addr_key, pred_ptr, addr_key, key, payload_ptr, retdest
-    // If we are here we know that addr <= pred_addr. But this is only possible if pred_addr == addr.
-    DUP3
-    %assert_eq
-    // stack: pred_ptr, addr_key, key, value, retdest
-    DUP1
-    %increment
-    MLOAD_GENERAL
-    // stack: pred_key, pred_ptr, addr_key, key, value, retdest
-    DUP1 DUP5
-    GT
-    %jumpi(insert_new_slot_with_value)
-    // stack: pred_key, pred_ptr, addr_key, key, value, retdest
-    DUP4
-    // We know that key <= pred_key. It must hold that pred_key == key.
-    %assert_eq
-    
-    // stack: pred_ptr, addr_key, key, value, retdest
-    // Check that this is not a deleted node
-    DUP1
-    %add_const(@STORAGE_NEXT_NODE_PTR)
-    MLOAD_GENERAL
-    %jump_neq_const(@U256_MAX, slot_found_write_value)
-    // The storage key is not in the list.
-    PANIC
-
-insert_new_slot_with_value:
-    // stack: pred_addr or pred_key, pred_ptr, addr_key, key, value, retdest
-    POP
-    // get the value of the next address
-    %add_const(@STORAGE_NEXT_NODE_PTR)
-    // stack: next_ptr_ptr, addr_key, key, value, retdest
-    %mload_global_metadata(@GLOBAL_METADATA_STORAGE_LINKED_LIST_NEXT_AVAILABLE)
-    DUP2
-    MLOAD_GENERAL
-    // stack: next_ptr, new_ptr, next_ptr_ptr, addr_key, key, value, retdest
-    // Check that this is not a deleted node
-    DUP1
-    %eq_const(@U256_MAX)
-    %assert_zero
-    DUP1
-    MLOAD_GENERAL
-    // stack: next_addr_key, next_ptr, new_ptr, next_ptr_ptr, addr_key, key, value, retdest
-    DUP1
-    DUP6
-    // Here, (addr_key > pred_addr_key) || (pred_ptr == @SEGMENT_ACCOUNTS_LINKED_LIST).
-    // We should have (addr_key < next_addr_key), meaning the new value can be inserted between pred_ptr and next_ptr.
-    LT
-    %jumpi(next_node_ok_with_value)
-    // If addr_key <= next_addr_key, then it addr must be equal to next_addr
-    // stack: next_addr_key, next_ptr, new_ptr, next_ptr_ptr, addr_key, key, value, retdest
-    DUP5
-    %assert_eq
-    // stack: next_ptr, new_ptr, next_ptr_ptr, addr_key, key, value, retdest
-    DUP1
-    %increment
-    MLOAD_GENERAL
-    // stack: next_key, next_ptr, new_ptr, next_ptr_ptr, addr_key, key, value, retdest
-    DUP1 // This is added just to have the correct stack in next_node_ok
-    DUP7
-    // The next key must be strictly larger
-    %assert_lt
-
-next_node_ok_with_value:
-    // stack: next_addr or next_key, next_ptr, new_ptr, next_ptr_ptr, addr_key, key, value, retdest
-    POP
-    // stack: next_ptr, new_ptr, next_ptr_ptr, addr_key, key, value, retdest
-    SWAP2
-    DUP2
-    // stack: new_ptr, next_ptr_ptr, new_ptr, next_ptr, addr_key, key, value, retdest
-    MSTORE_GENERAL
-    // stack: new_ptr, next_ptr, addr_key, key, value, retdest
-    // Write the address in the new node
-    DUP1
-    DUP4
-    MSTORE_GENERAL
-    // stack: new_ptr, next_ptr, addr_key, key, value, retdest
-    // Write the key in the new node
-    %increment
-    DUP1
-    DUP5
-    MSTORE_GENERAL
-    // stack: new_ptr + 1, next_ptr, addr_key, key, value, retdest
-    // Write the value in the linked list.
-    %increment
-    DUP1 %increment
-    // stack: new_ptr+3, new_value_ptr, next_ptr, addr_key, key, value, retdest
-    %stack (new_cloned_value_ptr, new_value_ptr, next_ptr, addr_key, key, value, retdest)
-        -> (value, new_cloned_value_ptr, value, new_value_ptr, new_cloned_value_ptr, next_ptr, retdest)
-    MSTORE_GENERAL // Store copied value.
-    MSTORE_GENERAL // Store value.
-
-    // stack: new_ptr + 3, next_ptr, retdest
-    %increment
-    DUP1
-    // stack: new_next_ptr_ptr, new_next_ptr_ptr, next_ptr, retdest
-    SWAP2
-    MSTORE_GENERAL
-    // stack: new_next_ptr_ptr, retdest
-    %increment
-    %mstore_global_metadata(@GLOBAL_METADATA_STORAGE_LINKED_LIST_NEXT_AVAILABLE)
-    // stack: retdest
-    JUMP
-
-slot_found_write_value:
-    // stack: pred_ptr, addr_key, key, value, retdest
-    %add_const(2)
-    %stack (payload_ptr, addr_key, key, value) -> (value, payload_ptr)
-    MSTORE_GENERAL
-    // stack: retdest
-    JUMP
-
-%macro insert_slot_with_value
-    // stack: addr, slot, value
-    %addr_to_state_key
-    SWAP1
-    %slot_to_storage_key
-    %stack (slot_key, addr_key, value) -> (addr_key, slot_key, value, %%after)
-    %jump(insert_slot_with_value)
-%%after:
-    // stack: (empty)
-%endmacro
-
-%macro insert_slot_with_value_from_keys
-    // stack: addr_key, slot_key, value
-    %stack (addr_key, slot_key, value) -> (addr_key, slot_key, value, %%after)
-    %jump(insert_slot_with_value)
-%%after:
-    // stack: (empty)
-%endmacro
-
-/// Inserts the pair (address_key, storage_key) and payload pointer into the linked list if it is not already present,
-/// or modifies its payload if it was already present.
-/// Returns `value` if the storage key was inserted, `old_value` if it was already present.
-global insert_slot:
-    // stack: addr_key, key, value, retdest
-    PROVER_INPUT(linked_list::insert_slot)
-    // stack: pred_ptr/5, addr_key, key, value, retdest
-    %get_valid_slot_ptr
-
-    // stack: pred_ptr, addr_key, key, value, retdest
-    DUP1
-    MLOAD_GENERAL
-    DUP1
-    // stack: pred_addr_key, pred_addr_key, pred_ptr, addr_key, key, value, retdest
-    DUP4 
-    GT
-    DUP3 %eq_const(@SEGMENT_STORAGE_LINKED_LIST)
-    ADD // OR
-    // If the predesessor is strictly smaller or the predecessor is the special
-    // node with key @U256_MAX (and hence we're inserting a new minimum), then
-    // we need to insert a new node.
-    %jumpi(insert_new_slot)
-    // stack: pred_addr_key, pred_ptr, addr_key, key, value, retdest
-    // If we are here we know that addr <= pred_addr. But this is only possible if pred_addr == addr.
-    DUP3
-    %assert_eq
-    // stack: pred_ptr, addr_key, key, value, retdest
-    DUP1
-    %increment
-    MLOAD_GENERAL
-    // stack: pred_key, pred_ptr, addr_key, key, value, retdest
-    DUP1 DUP5
-    GT
-    %jumpi(insert_new_slot)
-    // stack: pred_key, pred_ptr, addr_key, key, value, retdest
-    DUP4
-    // We know that key <= pred_key. It must hold that pred_key == key.
-    %assert_eq
-    // stack: pred_ptr, addr_key, key, value, retdest
-    
-    // stack: pred_ptr, addr_key, key, value, retdest
-    // Check that this is not a deleted node
-    DUP1
-    %add_const(@STORAGE_NEXT_NODE_PTR)
-    MLOAD_GENERAL
-    %jump_neq_const(@U256_MAX, slot_found_write)
-    // The storage key is not in the list.
-    PANIC
-
-slot_found_write:
-    // The slot was already in the list
-    // stack: pred_ptr, addr_key, key, value, retdest
-    // Load the old value
-    %add_const(2)
-    DUP1
-    MLOAD_GENERAL
-    // stack: old_value, pred_ptr + 2, addr_key, key, value, retdest
-    SWAP1
-    DUP5
-    MSTORE_GENERAL // Store the new value
-    %stack (old_value, addr_key, key, value, retdest) -> (retdest, old_value)
-    JUMP
-insert_new_slot:
-    // stack: pred_addr or pred_key, pred_ptr, addr_key, key, value, retdest
-    POP
-    // get the value of the next address
-    %add_const(@STORAGE_NEXT_NODE_PTR)
-    // stack: next_ptr_ptr, addr_key, key, value, retdest
-    %mload_global_metadata(@GLOBAL_METADATA_STORAGE_LINKED_LIST_NEXT_AVAILABLE)
-    DUP2
-    MLOAD_GENERAL
-    // stack: next_ptr, new_ptr, next_ptr_ptr, addr_key, key, value, retdest
-    // Check that this is not a deleted node
-    DUP1
-    %eq_const(@U256_MAX)
-    %assert_zero
-    DUP1
-    MLOAD_GENERAL
-    // stack: next_addr_key, next_ptr, new_ptr, next_ptr_ptr, addr_key, key, value, retdest
-    DUP1
-    DUP6
-    // Here, (addr_key > pred_addr_key) || (pred_ptr == @SEGMENT_ACCOUNTS_LINKED_LIST).
-    // We should have (addr_key < next_addr_key), meaning the new value can be inserted between pred_ptr and next_ptr.
-    LT
-    %jumpi(next_node_ok)
-    // If addr_key <= next_addr_key, then it addr must be equal to next_addr
-    // stack: next_addr_key, next_ptr, new_ptr, next_ptr_ptr, addr_key, key, value, retdest
-    DUP5
-    %assert_eq
-    // stack: next_ptr, new_ptr, next_ptr_ptr, addr_key, key, value, retdest
-    DUP1
-    %increment
-    MLOAD_GENERAL
-    // stack: next_key, next_ptr, new_ptr, next_ptr_ptr, addr_key, key, value, retdest
-    DUP1 // This is added just to have the correct stack in next_node_ok
-    DUP7
-    // The next key must be strictly larger
-    %assert_lt
-next_node_ok:
-    // stack: next_addr or next_key, next_ptr, new_ptr, next_ptr_ptr, addr_key, key, value, retdest
-    POP
-    // stack: next_ptr, new_ptr, next_ptr_ptr, addr_key, key, value, retdest
-    SWAP2
-    DUP2
-    // stack: new_ptr, next_ptr_ptr, new_ptr, next_ptr, addr_key, key, value, retdest
-    MSTORE_GENERAL
-    // stack: new_ptr, next_ptr, addr_key, key, value, retdest
-    // Write the address in the new node
-    DUP1
-    DUP4
-    MSTORE_GENERAL
-    // stack: new_ptr, next_ptr, addr_key, key, value, retdest
-    // Write the key in the new node
-    %increment
-    DUP1
-    DUP5
-    MSTORE_GENERAL
-    // stack: new_ptr + 1, next_ptr, addr_key, key, value, retdest
-    // Store value
-    %increment
-    DUP1
-    DUP6
-    MSTORE_GENERAL
-
-    // stack: new_ptr + 2, next_ptr, addr_key, key, value, retdest
-    // Store the copy of value
-    %increment
-    DUP1
-    DUP6
-    %clone_slot
-    MSTORE_GENERAL
-    // stack: new_ptr + 3, next_ptr, addr_key, key, value, retdest
-    %increment
-    DUP1
-    // stack: new_next_ptr, new_next_ptr, next_ptr, addr_key, key, value, retdest
-    SWAP2
-    MSTORE_GENERAL
-    // stack: new_next_ptr, addr_key, key, value, retdest
-    %increment
-    %mstore_global_metadata(@GLOBAL_METADATA_STORAGE_LINKED_LIST_NEXT_AVAILABLE)
-    // stack: addr_key, key, value, retdest
-    %stack (addr_key, key, value, retdest) -> (retdest, value)
-    JUMP
-
-/// Searches the pair (address_key, storage_key) in the storage the linked list.
-/// Returns `value` if the storage key was inserted, `old_value` if it was already present.
-global search_slot:
-    // stack: addr_key, key, value, retdest
-    PROVER_INPUT(linked_list::search_slot)
-    // stack: pred_ptr/5, addr_key, key, value, retdest
-    %get_valid_slot_ptr
-
-    // stack: pred_ptr, addr_key, key, value, retdest
-    DUP1
-    MLOAD_GENERAL
-    DUP1
-    // stack: pred_addr_key, pred_addr_key, pred_ptr, addr_key, key, value, retdest
-    DUP4 
-    GT
-    DUP3 %eq_const(@SEGMENT_STORAGE_LINKED_LIST)
-    ADD // OR
-    // If the predesessor is strictly smaller or the predecessor is the special
-    // node with key @U256_MAX (and hence we're inserting a new minimum), then
-    // the slot was not found
-    %jumpi(slot_not_found)
-    // stack: pred_addr_key, pred_ptr, addr_key, key, value, retdest
-    // If we are here we know that addr <= pred_addr. But this is only possible if pred_addr == addr.
-    DUP3
-    %assert_eq
-    // stack: pred_ptr, addr_key, key, value, retdest
-    DUP1
-    %increment
-    MLOAD_GENERAL
-    // stack: pred_key, pred_ptr, addr_key, key, value, retdest
-    DUP1 DUP5
-    GT
-    %jumpi(slot_not_found)
-    // stack: pred_key, pred_ptr, addr_key, key, value, retdest
-    DUP4
-    // We know that key <= pred_key. It must hold that pred_key == key.
-    %assert_eq
-    // stack: pred_ptr, addr_key, key, value, retdest
-    
-    // stack: pred_ptr, addr_key, key, value, retdest
-    // Check that this is not a deleted node
-    DUP1
-    %add_const(@STORAGE_NEXT_NODE_PTR)
-    MLOAD_GENERAL
-    %jump_neq_const(@U256_MAX, slot_found_no_write)
-    // The storage key is not in the list.
-    PANIC
-slot_not_found:    
-    // stack: pred_addr_or_pred_key, pred_ptr, addr_key, key, value, retdest
-    %stack (pred_addr_or_pred_key, pred_ptr, addr_key, key, value, retdest)
-        -> (retdest, value)
-    JUMP
-
-slot_found_no_write:
-    // The slot was already in the list
-    // stack: pred_ptr, addr_key, key, value, retdest
-    // Load the old value
-    %add_const(2)
-    MLOAD_GENERAL
-    // stack: old_value, addr_key, key, value, retdest
-    %stack (old_value, addr_key, key, value, retdest) -> (retdest, old_value)
-    JUMP
-
-%macro search_slot
-    // stack: state_key, storage_key, ptr
-    %stack (state_key, storage_key, ptr) -> (state_key, storage_key, ptr, %%after)
-    %jump(search_slot)
-%%after:
-    // stack: value
-%endmacro
-
-%macro remove_slot
-    %stack (key, addr_key) -> (addr_key, key, %%after)
-    %jump(remove_slot)
-%%after:
-%endmacro
-
-/// Removes the storage key and its value from the list.
-/// Panics if the key is not in the list.
-global remove_slot:
-    // stack: addr_key, key, retdest
-    PROVER_INPUT(linked_list::remove_slot)
-    // stack: pred_ptr/5, addr_key, key, retdest
-    %get_valid_slot_ptr
-    // stack: pred_ptr, addr_key, key, retdest
-    %add_const(@STORAGE_NEXT_NODE_PTR)
-    // stack: next_ptr_ptr, addr_key, key, retdest
-    DUP1
-    MLOAD_GENERAL
-    // stack: next_ptr, next_ptr_ptr, addr_key, key, retdest
-    DUP1
-    MLOAD_GENERAL
-    // stack: next_addr_key, next_ptr, next_ptr_ptr, addr_key, key, retdest
-    DUP4
-    %assert_eq
-    // stack: next_ptr, next_ptr_ptr, addr_key, key, retdest
-    DUP1
-    %increment
-    MLOAD_GENERAL
-    // stack: next_key, next_ptr, next_ptr_ptr, addr_key, key, retdest
-    DUP5
-    %assert_eq
-    // stack: next_ptr, next_ptr_ptr, addr_key, key, retdest
-    %add_const(@STORAGE_NEXT_NODE_PTR)
-    // stack: next_next_ptr_ptr, next_ptr_ptr, addr_key, key, retdest
-    DUP1
-    MLOAD_GENERAL
-    // stack: next_next_ptr, next_next_ptr_ptr, next_ptr_ptr, addr_key, key, retdest
-    // Mark the next node as deleted
-    SWAP1
-    %mstore_u256_max
-    // stack: next_next_ptr, next_ptr_ptr, addr_key, key, retdest
-    MSTORE_GENERAL
-    %pop2
-    JUMP
-
-/// Called when an account is deleted: it deletes all slots associated with the account.
-global remove_all_account_slots:
-    // stack: addr_key, retdest
-    PROVER_INPUT(linked_list::remove_address_slots)
-    // pred_ptr/5, retdest
-    %get_valid_slot_ptr
-    // stack: pred_ptr, addr_key, retdest
-    // First, check that the previous address is not `addr`
-    DUP1 MLOAD_GENERAL
-    // stack: pred_addr_key, pred_ptr, addr_key, retdest
-    DUP3 EQ %jumpi(panic)
-    // stack: pred_ptr, addr_key, retdest
-    DUP1
-
-// Now, while the next address is `addr`, remove the next slot.
-remove_all_slots_loop:
-    // stack: pred_ptr, pred_ptr, addr_key, retdest
-    %add_const(@STORAGE_NEXT_NODE_PTR) DUP1 MLOAD_GENERAL
-    // stack: cur_ptr, cur_ptr_ptr, pred_ptr, addr_key, retdest
-    DUP1 %eq_const(@U256_MAX) %jumpi(remove_all_slots_end)
-    DUP1 %add_const(@STORAGE_NEXT_NODE_PTR) MLOAD_GENERAL 
-    // stack: next_ptr, cur_ptr, cur_ptr_ptr, pred_ptr, addr_key, retdest
-    SWAP1 DUP1
-    // stack: cur_ptr, cur_ptr, next_ptr, cur_ptr_ptr, pred_ptr, addr_key, retdest
-    MLOAD_GENERAL
-    DUP6 EQ ISZERO %jumpi(remove_all_slots_pop_and_end)
-    
-    // Remove slot: update the value in cur_ptr_ptr, and set cur_ptr+4 to @U256_MAX.
-    // stack: cur_ptr, next_ptr, cur_ptr_ptr, pred_ptr, addr_key, retdest
-    SWAP2 SWAP1
-    // stack: next_ptr, cur_ptr_ptr, cur_ptr, pred_ptr, addr_key, retdest
-    MSTORE_GENERAL
-    // stack: cur_ptr, pred_ptr, addr_key, retdest
-    %add_const(@STORAGE_NEXT_NODE_PTR) 
-    %mstore_u256_max
-    // stack: pred_ptr, addr_key, retdest
-    DUP1
-    %jump(remove_all_slots_loop)
-
-remove_all_slots_pop_and_end:
-    POP
-remove_all_slots_end:
-    // stack: next_ptr, cur_ptr_ptr, pred_ptr, addr_key, retdest
-    %pop4 JUMP
-
-%macro remove_all_account_slots
-    %stack (addr_key) -> (addr_key, %%after)
-    %jump(remove_all_account_slots)
-%%after:
-%endmacro
-
-%macro read_accounts_linked_list
-    %stack (addr) -> (addr, %%after)
-    %addr_to_state_key
-    %jump(search_account)
-%%after:
-    // stack: account_ptr
-%endmacro
-
-%macro read_storage_linked_list
-    // stack: slot
-    %slot_to_storage_key
-    %stack (storage_key) -> (storage_key, 0, %%after)
-    %address
-    %addr_to_state_key
-    // stack: addr_key, storage_key, 0, %%after
-    %jump(search_slot)
-%%after:
-    // stack: slot_value
-%endmacro
-
-%macro read_storage_linked_list_w_addr
-    // stack: slot, address
-    %slot_to_storage_key
-    %stack (storage_key, address) -> (address, storage_key, 0, %%after)
-    %addr_to_state_key
-    // stack: addr_key, storage_key, 0, %%after
-    %jump(search_slot)
-%%after:
-    // stack: slot_value
-%endmacro
-
-%macro read_storage_linked_list_w_state_key
-    // stack: slot, state_key
-    %slot_to_storage_key
-    %stack (storage_key, state_key) -> (state_key, storage_key, 0, %%after)
-    %jump(search_slot)
-%%after:
-    // stack: slot_ptr
-%endmacro
-
-%macro first_account
-    // stack: empty
-    PUSH @SEGMENT_ACCOUNTS_LINKED_LIST
-    %next_account
-%endmacro
-
-%macro first_initial_account
-    // stack: empty
-    PUSH @SEGMENT_ACCOUNTS_LINKED_LIST
-    %next_initial_account
-%endmacro
-
-%macro next_account
-    // stack: node_ptr
-    %add_const(@ACCOUNTS_NEXT_NODE_PTR)
-    MLOAD_GENERAL
-    // stack: next_node_ptr
-%endmacro
-
-%macro next_initial_account
-    // stack: node_ptr
-    %add_const(@ACCOUNTS_LINKED_LISTS_NODE_SIZE)
-    // stack: next_node_ptr
-%endmacro
-
-%macro first_slot
-    // stack: empty
-    PUSH @SEGMENT_STORAGE_LINKED_LIST
-    %next_slot
-%endmacro
-
-%macro first_initial_slot
-    // stack: empty
-    PUSH @SEGMENT_STORAGE_LINKED_LIST
-    %next_initial_slot
-%endmacro
-
-%macro next_slot
-    // stack: node_ptr
-    %add_const(@STORAGE_NEXT_NODE_PTR)
-    MLOAD_GENERAL
-    // stack: next_node_ptr
-%endmacro
-
-%macro next_initial_slot
-    // stack: node_ptr
-    %add_const(@STORAGE_LINKED_LISTS_NODE_SIZE)
-    // stack: next_node_ptr
-%endmacro
-
-%macro next_hash_node
-    // stack: hash_node_ptr
-    %add_const(4)
-    // stack: next_hash_node_ptr
-%endmacro
-
-// Skip over the the first three words (number of nibbles and keys)
-// and load the hash from memory.
-%macro get_hash
-    // stack: hash_node_ptr
-    %add_const(3)
-    // stack: next_ptr
-    MLOAD_GENERAL
-    // stack: hash
-%endmacro
diff --git a/evm_arithmetization/src/cpu/kernel/asm/mpt/read.asm b/evm_arithmetization/src/cpu/kernel/asm/mpt/read.asm
index 86f8ae190..1c007d98c 100644
--- a/evm_arithmetization/src/cpu/kernel/asm/mpt/read.asm
+++ b/evm_arithmetization/src/cpu/kernel/asm/mpt/read.asm
@@ -1,20 +1,23 @@
 // Given an address, return a pointer to the associated account data, which
 // consists of four words (nonce, balance, storage_root, code_hash), in the
 // trie_data segment. Return null if the address is not found.
-global mpt_read_state_trie:
-    // stack: addr, retdest
-    %read_accounts_linked_list
-    // stack: account_ptr, retdest
-    SWAP1
-    // stack: retdest, account_ptr
-    JUMP
+#[cfg(not(feature = cdk_erigon))]
+{
+    global mpt_read_state_trie:
+        // stack: addr, retdest
+        %read_account_from_addr
+        // stack: account_ptr, retdest
+        SWAP1
+        // stack: retdest, account_ptr
+        JUMP
 
-// Convenience macro to call mpt_read_state_trie and return where we left off.
-%macro mpt_read_state_trie
-    %stack (addr) -> (addr, %%after)
-    %jump(mpt_read_state_trie)
-%%after:
-%endmacro
+    // Convenience macro to call mpt_read_state_trie and return where we left off.
+    %macro mpt_read_state_trie
+        %stack (addr) -> (addr, %%after)
+        %jump(mpt_read_state_trie)
+    %%after:
+    %endmacro
+}
 
 // Read a value from a MPT.
 //
diff --git a/evm_arithmetization/src/cpu/kernel/asm/mpt/storage/storage_read.asm b/evm_arithmetization/src/cpu/kernel/asm/mpt/storage/storage_read.asm
index 882a85973..5cdb18a69 100644
--- a/evm_arithmetization/src/cpu/kernel/asm/mpt/storage/storage_read.asm
+++ b/evm_arithmetization/src/cpu/kernel/asm/mpt/storage/storage_read.asm
@@ -5,7 +5,8 @@
 %endmacro
 
 global sload_current:
-    %read_storage_linked_list
+    // stack: slot, retdest
+    %read_slot_from_current_addr
     // stack: value, retdest
     SWAP1
     JUMP
diff --git a/evm_arithmetization/src/cpu/kernel/asm/mpt/storage/storage_write.asm b/evm_arithmetization/src/cpu/kernel/asm/mpt/storage/storage_write.asm
index 589c44094..91bb61e2a 100644
--- a/evm_arithmetization/src/cpu/kernel/asm/mpt/storage/storage_write.asm
+++ b/evm_arithmetization/src/cpu/kernel/asm/mpt/storage/storage_write.asm
@@ -103,6 +103,14 @@ sstore_after_refund:
     %stack (kexit_info, current_value, slot, value) -> (value, current_value, current_value, slot, value, kexit_info)
     EQ %jumpi(sstore_noop)
 
+    // stack: current_value, slot, value, kexit_info
+    DUP1 ISZERO
+    // stack: current_value==0, current_value, slot, value, kexit_info
+    DUP4 MUL
+    // stack: value & current_value==0, current_value, slot, value, kexit_info
+    %jumpi(new_storage_slot)
+global not_new_storage_slot:
+
     // stack: current_value, slot, value, kexit_info
     DUP2 %address %journal_add_storage_change
     // stack: slot, value, kexit_info
@@ -114,7 +122,7 @@ sstore_after_refund:
 
     // stack: slot, value, kexit_info
     %address
-    %insert_slot_with_value
+    %insert_slot
 
     EXIT_KERNEL
 
@@ -127,10 +135,39 @@ sstore_noop:
 sstore_delete:
     // stack: slot, value, kexit_info
     %address
-    %addr_to_state_key
-    // stack: addr_key, slot, value, kexit_info
-    SWAP2 POP
-    // stack: slot, addr_key, kexit_info
-    %slot_to_storage_key
-    %remove_slot
+    // stack: addr, slot, value, kexit_info
+    %remove_slot_from_addr
+    // stack: value, kexit_info
+    POP
     EXIT_KERNEL
+
+%macro insert_new_storage_slot
+    // stack: address, slot
+    %mload_global_metadata(@GLOBAL_METADATA_NEW_STORAGE_SLOTS_LEN)
+    // stack: list_len, address, slot
+    DUP1 %add_const(@SEGMENT_NEW_STORAGE_SLOTS)
+    // stack: index, list_len, address, slot
+    DUP1 %add_const(1)
+    %stack (index_plus_1, index, list_len, address, slot) -> (address, index, slot, index_plus_1, list_len)
+    MSTORE_GENERAL MSTORE_GENERAL
+    // stack: list_len
+    %add_const(2)
+    // stack: list_len+2
+    %mstore_global_metadata(@GLOBAL_METADATA_NEW_STORAGE_SLOTS_LEN)
+    // stack: (empty)
+%endmacro
+
+new_storage_slot:
+    // stack: current_value, slot, value, kexit_info
+    %address DUP1 %contract_just_created
+    // stack: contract_just_created, address, current_value, slot, value, kexit_info
+    %jumpi(new_storage_slot_new_contract)
+    // stack: address, current_value, slot, value, kexit_info
+    POP %jump(not_new_storage_slot)
+new_storage_slot_new_contract:
+    // stack: address, current_value, slot, value, kexit_info
+    DUP3 SWAP1
+    // stack: address, slot, current_value, slot, value, kexit_info
+    %insert_new_storage_slot
+    // stack: current_value, slot, value, kexit_info
+    %jump(not_new_storage_slot)
diff --git a/evm_arithmetization/src/cpu/kernel/asm/smt/delete.asm b/evm_arithmetization/src/cpu/kernel/asm/smt/delete.asm
new file mode 100644
index 000000000..f0fba3897
--- /dev/null
+++ b/evm_arithmetization/src/cpu/kernel/asm/smt/delete.asm
@@ -0,0 +1,293 @@
+%macro smt_delete_state
+    %stack (key) -> (key, %%after)
+    %mload_global_metadata(@GLOBAL_METADATA_STATE_TRIE_ROOT) // node_ptr
+    // stack: node_ptr, key, retdest
+    %jump(smt_delete)
+%%after:
+    // stack: new_node_ptr
+    %mstore_global_metadata(@GLOBAL_METADATA_STATE_TRIE_ROOT)
+    // stack: (emtpy)
+%endmacro
+
+// Return a copy of the given node with the given key deleted.
+// Assumes that the key is in the SMT.
+//
+// Pre stack: node_ptr, key, retdest
+// Post stack: updated_node_ptr
+global smt_delete:
+    // stack: node_ptr, key, retdest
+    SWAP1 %split_key
+    %stack (k0, k1, k2, k3, node_ptr) -> (node_ptr, 0, k0, k1, k2, k3)
+smt_delete_with_keys:
+    // stack: node_ptr, level, ks, retdest
+    DUP1 %mload_trie_data
+    // stack: node_type, node_ptr, level, ks, retdest
+    // Increment node_ptr, so it points to the node payload instead of its type.
+    SWAP1 %increment SWAP1
+    // stack: node_type, node_payload_ptr, level, ks, retdest
+
+    DUP1 %eq_const(@SMT_NODE_INTERNAL)  %jumpi(smt_delete_internal)
+         %eq_const(@SMT_NODE_LEAF)      %jumpi(smt_delete_leaf)
+    PANIC // Should never happen.
+
+smt_delete_leaf:
+    // stack: node_payload_ptr, level, ks, retdest
+    %pop6
+    PUSH 0 // empty node ptr
+    SWAP1 JUMP
+
+smt_delete_internal:
+    // stack: node_type, node_payload_ptr, level, ks, retdest
+    POP
+    // stack: node_payload_ptr, level, ks, retdest
+    DUP2 %and_const(3) // level mod 4
+    // stack: level%4, node_payload_ptr, level, ks, retdest
+    DUP1 %eq_const(0) %jumpi(smt_delete_internal_0)
+    DUP1 %eq_const(1) %jumpi(smt_delete_internal_1)
+    DUP1 %eq_const(2) %jumpi(smt_delete_internal_2)
+         %eq_const(3) %jumpi(smt_delete_internal_3)
+    PANIC
+smt_delete_internal_0:
+    // stack: level%4, node_payload_ptr, level, ks, retdest
+    %stack (level_mod_4, node_payload_ptr, level, k0, k1, k2, k3 ) -> (k0, node_payload_ptr, level, k0, k1, k2, k3 )
+    %pop_bit
+    %stack (bit, newk0, node_payload_ptr, level, k0, k1, k2, k3 ) -> (bit, node_payload_ptr, level, newk0, k1, k2, k3 )
+    %jump(smt_delete_internal_contd)
+smt_delete_internal_1:
+    %stack (level_mod_4, node_payload_ptr, level, k0, k1, k2, k3 ) -> (k1, node_payload_ptr, level, k0, k1, k2, k3 )
+    %pop_bit
+    %stack (bit, newk1, node_payload_ptr, level, k0, k1, k2, k3 ) -> (bit, node_payload_ptr, level, k0, newk1, k2, k3 )
+    %jump(smt_delete_internal_contd)
+smt_delete_internal_2:
+    %stack (level_mod_4, node_payload_ptr, level, k0, k1, k2, k3 ) -> (k2, node_payload_ptr, level, k0, k1, k2, k3 )
+    %pop_bit
+    %stack (bit, newk2, node_payload_ptr, level, k0, k1, k2, k3 ) -> (bit, node_payload_ptr, level, k0, k1, newk2, k3 )
+    %jump(smt_delete_internal_contd)
+smt_delete_internal_3:
+    %stack (node_payload_ptr, level, k0, k1, k2, k3 ) -> (k3, node_payload_ptr, level, k0, k1, k2, k3 )
+    %pop_bit
+    %stack (bit, newk3, node_payload_ptr, level, k0, k1, k2, k3 ) -> (bit, node_payload_ptr, level, k0, k1, k2, newk3 )
+smt_delete_internal_contd:
+    //stack: bit, node_payload_ptr, level, k0, k1, k2, k3, retdest
+    PUSH internal_update
+    //stack: internal_update, bit, node_payload_ptr, level, k0, k1, k2, k3, retdest
+    %rep 7
+        DUP8
+    %endrep
+    //stack: bit, node_payload_ptr, level, k0, k1, k2, k3, internal_update, bit, node_payload_ptr, level, k0, k1, k2, k3, retdest
+    ADD
+    //stack: child_ptr_ptr, level, k0, k1, k2, k3, internal_update, bit, node_payload_ptr, level, k0, k1, k2, k3, retdest
+    %mload_trie_data
+    //stack: child_ptr, level, k0, k1, k2, k3, internal_update, bit, node_payload_ptr, level, k0, k1, k2, k3, retdest
+    SWAP1 %increment SWAP1
+    //stack: child_ptr, level+1, k0, k1, k2, k3, internal_update, bit, node_payload_ptr, level, k0, k1, k2, k3, retdest
+    %jump(smt_delete_with_keys)
+
+// Update the internal node, possibly deleting it, or returning a leaf node.
+internal_update:
+    // Update the child first.
+    //stack: deleted_child_ptr, bit, node_payload_ptr, level, ks, retdest
+    DUP2 PUSH 1 SUB
+    //stack: 1-bit, deleted_child_ptr, bit, node_payload_ptr, level, ks, retdest
+    DUP4 ADD
+    //stack: sibling_ptr_ptr, deleted_child_ptr, bit, node_payload_ptr, level, ks, retdest
+    %mload_trie_data DUP1 %mload_trie_data
+    //stack: sibling_node_type, sibling_ptr, deleted_child_ptr, bit, node_payload_ptr, level, ks, retdest
+    DUP1 %eq_const(@SMT_NODE_HASH)     %jumpi(sibling_is_hash)
+    DUP1 %eq_const(@SMT_NODE_LEAF)     %jumpi(sibling_is_leaf)
+         %eq_const(@SMT_NODE_INTERNAL) %jumpi(sibling_is_internal)
+    PANIC // Should never happen.
+sibling_is_internal:
+    //stack: sibling_ptr, deleted_child_ptr, bit, node_payload_ptr, level, ks, retdest
+    POP
+insert_child:
+    //stack: deleted_child_ptr, bit, node_payload_ptr, level, ks, retdest
+    %stack (deleted_child_ptr, bit, node_payload_ptr) -> (node_payload_ptr, bit, deleted_child_ptr, node_payload_ptr)
+    ADD %mstore_trie_data
+    // stack: node_payload_ptr, level, ks, retdest
+    %decrement
+    %stack (node_ptr, level, k0, k1, k2, k3, retdest) -> (retdest, node_ptr)
+    JUMP
+
+sibling_is_hash:
+    // stack: sibling_node_type, sibling_ptr, deleted_child_ptr, bit, node_payload_ptr, level, ks, retdest
+    POP
+    //stack: sibling_ptr, deleted_child_ptr, bit, node_payload_ptr, level, ks, retdest
+    %increment %mload_trie_data
+    // stack: hash, deleted_child_ptr, bit, node_payload_ptr, level, ks, retdest
+    %jumpi(insert_child) // Sibling is non-empty hash node.
+sibling_is_empty:
+    // stack: deleted_child_ptr, bit, node_payload_ptr, level, ks, retdest
+    DUP1 %mload_trie_data
+    // stack: deleted_child_node_type, deleted_child_ptr, bit, node_payload_ptr, level, ks, retdest
+    DUP1 %eq_const(@SMT_NODE_HASH) %jumpi(sibling_is_empty_child_is_hash)
+    DUP1 %eq_const(@SMT_NODE_LEAF) %jumpi(sibling_is_empty_child_is_leaf)
+sibling_is_empty_child_is_internal:
+    // stack: deleted_child_node_type, deleted_child_ptr, bit, node_payload_ptr, level, ks, retdest
+    POP
+    // stack: deleted_child_ptr, bit, node_payload_ptr, level, ks, retdest
+    %jump(insert_child)
+
+sibling_is_empty_child_is_hash:
+    // stack: deleted_child_node_type, deleted_child_ptr, bit, node_payload_ptr, level, ks, retdest
+    POP
+    // stack: deleted_child_ptr, bit, node_payload_ptr, level, ks, retdest
+    DUP1 %increment %mload_trie_data
+    // stack: hash, deleted_child_ptr, bit, node_payload_ptr, level, ks, retdest
+    %jumpi(insert_child)
+sibling_is_empty_child_is_empty:
+    // We can just delete this node.
+    // stack: deleted_child_ptr, bit, node_payload_ptr, level, ks, retdest
+    %pop8
+    SWAP1 PUSH 0
+    // stack: retdest, 0
+    JUMP
+
+sibling_is_empty_child_is_leaf:
+    // stack: deleted_child_node_type, deleted_child_ptr, bit, node_payload_ptr, level, ks, retdest
+    POP
+    // stack: deleted_child_ptr, bit, node_payload_ptr, level, k0, k1, k2, k3, retdest
+    %increment
+    // stack: deleted_child_key_ptr, bit, node_payload_ptr, level, k0, k1, k2, k3, retdest
+    DUP4
+    // stack: level, deleted_child_key_ptr, bit, node_payload_ptr, level, k0, k1, k2, k3, retdest
+    DUP3
+    // stack: bit, level, deleted_child_key_ptr, bit, node_payload_ptr, level, k0, k1, k2, k3, retdest
+    DUP3 %mload_trie_data
+    // stack: child_key, bit, level, deleted_child_key_ptr, bit, node_payload_ptr, level, k0, k1, k2, k3, retdest
+    %recombine_key
+    // stack: new_child_key, deleted_child_key_ptr, bit, node_payload_ptr, level, k0, k1, k2, k3, retdest
+    DUP2 %mstore_trie_data
+    // stack: deleted_child_key_ptr, bit, node_payload_ptr, level, k0, k1, k2, k3, retdest
+    %decrement
+    // stack: deleted_child_ptr, bit, node_payload_ptr, level, k0, k1, k2, k3, retdest
+    SWAP7
+    // stack: k3, bit, node_payload_ptr, level, k0, k1, k2, deleted_child_ptr, retdest
+    %pop7
+    // stack: deleted_child_ptr, retdest
+    SWAP1 JUMP
+
+sibling_is_leaf:
+    // stack: sibling_node_type, sibling_ptr, deleted_child_ptr, bit, node_payload_ptr, level, ks, retdest
+    POP
+    // stack: sibling_ptr, deleted_child_ptr, bit, node_payload_ptr, level, ks, retdest
+    DUP2 %is_non_empty_node
+    // stack: child_is_non_empty, sibling_ptr, deleted_child_ptr, bit, node_payload_ptr, level, ks, retdest
+    %jumpi(sibling_is_leaf_child_is_non_empty)
+sibling_is_leaf_child_is_empty:
+    // stack: sibling_ptr, deleted_child_ptr, bit, node_payload_ptr, level, ks, retdest
+    %increment
+    // stack: sibling_key_ptr, deleted_child_ptr, bit, node_payload_ptr, level, k0, k1, k2, k3, retdest
+    DUP5
+    // stack: level, sibling_key_ptr, deleted_child_ptr, bit, node_payload_ptr, level, k0, k1, k2, k3, retdest
+    DUP4
+    // stack: bit, level, sibling_key_ptr, deleted_child_ptr, bit, node_payload_ptr, level, k0, k1, k2, k3, retdest
+    PUSH 1 SUB
+    // stack: obit, level, sibling_key_ptr, deleted_child_ptr, bit, node_payload_ptr, level, k0, k1, k2, k3, retdest
+    DUP3 %mload_trie_data
+    // stack: sibling_key, obit, level, sibling_key_ptr, deleted_child_ptr, bit, node_payload_ptr, level, k0, k1, k2, k3, retdest
+    %recombine_key
+    // stack: new_key, sibling_key_ptr, deleted_child_ptr, bit, node_payload_ptr, level, k0, k1, k2, k3, retdest
+    DUP2 %mstore_trie_data
+    // stack: sibling_key_ptr, deleted_child_ptr, bit, node_payload_ptr, level, k0, k1, k2, k3, retdest
+    %decrement
+    // stack: sibling_ptr, deleted_child_ptr, bit, node_payload_ptr, level, k0, k1, k2, k3, retdest
+    SWAP8
+    // stack: k3, deleted_child_ptr, bit, node_payload_ptr, level, k0, k1, k2, sibling_ptr, retdest
+    %pop8
+    // stack: sibling_ptr, retdest
+    SWAP1 JUMP
+
+sibling_is_leaf_child_is_non_empty:
+    // stack: sibling_ptr, deleted_child_ptr, bit, node_payload_ptr, level, ks, retdest
+    POP
+    // stack: deleted_child_ptr, node_payload_ptr, bit, retdest
+    %jump(insert_child)
+
+
+global delete_account:
+    %stack (address, retdest) -> (address, retdest)
+    DUP1 %key_nonce
+    // stack: key_nonce, address, retdest
+    DUP1 %search_key ISZERO %jumpi(zero_nonce)
+    // stack: key_nonce, address, retdest
+    DUP1 %remove_key
+    // stack: key_nonce, address, retdest
+zero_nonce:
+    // stack: key_nonce, address, retdest
+    POP
+    // stack: address, retdest
+    DUP1 %key_balance
+    // stack: key_balance, address, retdest
+    DUP1 %search_key ISZERO %jumpi(zero_balance)
+    // stack: key_balance, address, retdest
+    DUP1 %remove_key
+    // stack: key_balance, address, retdest
+zero_balance:
+    // stack: key_balance, address, retdest
+    POP
+    // stack: address, retdest
+    DUP1 %key_code
+    // stack: key_code, address, retdest
+    DUP1 %search_key ISZERO %jumpi(zero_code)
+    // stack: key_code, address, retdest
+    DUP1 %remove_key
+    // stack: key_code, address, retdest
+zero_code:
+    // stack: key_code, address, retdest
+    POP
+    // stack: address, retdest
+    DUP1 %key_code_length
+    // stack: key_code_length, address, retdest
+    DUP1 %search_key ISZERO %jumpi(zero_code_length)
+    // stack: key_code_length, address, retdest
+    DUP1 %remove_key
+zero_code_length:
+    // N.B.: We don't delete the storage, since there's no way of knowing keys used.
+    // stack: key_code_length, address, retdest
+    POP
+    // stack: address, retdest
+    %mload_global_metadata(@GLOBAL_METADATA_NEW_STORAGE_SLOTS_LEN)
+    // stack: slots_len, address, retdest
+    PUSH 0
+    // stack: i, slots_len, address, retdest
+delete_storage_slots_loop:
+    // stack: i, slots_len, address, retdest
+    DUP2 DUP2 EQ %jumpi(delete_storage_slots_loop_end)
+    // stack: i, slots_len, address, retdest
+    DUP1 %add_const(@SEGMENT_NEW_STORAGE_SLOTS)
+    // stack: addr_index, i, slots_len, address, retdest
+    MLOAD_GENERAL
+    // stack: slot_addr, i, slots_len, address, retdest
+    DUP4 EQ
+    // stack: address==slot_addr, i, slots_len, address, retdest
+    %jumpi(delete_storage_slot)
+    // stack: i, slots_len, address, retdest
+    %add_const(2) %jump(delete_storage_slots_loop)
+delete_storage_slot:
+    // stack: i, slots_len, address, retdest
+    DUP1 %increment %add_const(@SEGMENT_NEW_STORAGE_SLOTS)
+    // stack: slot_index, i, slots_len, address, retdest
+    MLOAD_GENERAL
+    // stack: slot, i, slots_len, address, retdest
+    DUP4 %key_storage
+    // stack: key_storage, i, slots_len, address, retdest
+    DUP1 %search_key ISZERO %jumpi(zero_slot)
+    // stack: key_storage, i, slots_len, address, retdest
+    DUP1 %remove_key
+zero_slot:
+    // stack: key_storage, i, slots_len, address, retdest
+    POP
+    // stack: i, slots_len, address, retdest
+    %add_const(2) %jump(delete_storage_slots_loop)
+
+delete_storage_slots_loop_end:
+    // stack: i, slots_len, address, retdest
+    %pop3 JUMP
+
+%macro delete_account
+    %stack (address) -> (address, %%after)
+    %jump(delete_account)
+%%after:
+    // stack: (empty)
+%endmacro
diff --git a/evm_arithmetization/src/cpu/kernel/asm/smt/hash.asm b/evm_arithmetization/src/cpu/kernel/asm/smt/hash.asm
new file mode 100644
index 000000000..2d9ec1902
--- /dev/null
+++ b/evm_arithmetization/src/cpu/kernel/asm/smt/hash.asm
@@ -0,0 +1,92 @@
+%macro hash_state_trie
+    %stack (cur_len) -> (cur_len, %%after)
+    %jump(hash_state_trie)
+%%after:
+%endmacro
+
+// Root hash of the state SMT.
+global hash_state_trie:
+    // stack: cur_len, retdest
+    %mload_global_metadata(@GLOBAL_METADATA_STATE_TRIE_ROOT)
+
+// Root hash of SMT stored at `trie_data[ptr]`.
+// Pseudocode:
+// ```
+// hash( HashNode { h } ) = h
+// hash( InternalNode { left, right } ) = Poseidon(hash(left) || hash(right) || [0,0,0,0])
+// hash( Leaf { rem_key, val_hash } ) = Poseidon(rem_key || val_hash || [1,0,0,0])
+// ```
+global smt_hash:
+    // stack: ptr, cur_len, retdest
+    DUP1
+    %mload_trie_data
+    // stack: node, node_ptr, cur_len, retdest
+    DUP1 %eq_const(@SMT_NODE_HASH)     %jumpi(smt_hash_hash)
+    DUP1 %eq_const(@SMT_NODE_INTERNAL) %jumpi(smt_hash_internal)
+         %eq_const(@SMT_NODE_LEAF)     %jumpi(smt_hash_leaf)
+smt_hash_unknown_node_type:
+    PANIC
+
+smt_hash_hash:
+global debug_hash_hash:
+    // stack: node, node_ptr, cur_len, retdest
+    POP
+    // stack: node_ptr, cur_len, retdest
+    DUP1 ISZERO %jumpi(empty_hash_node) // We don't count empty hash nodes
+    SWAP1 %add_const(2) SWAP1
+empty_hash_node:
+    // stack: node_ptr, cur_len, retdest
+    %increment
+    // stack: node_ptr+1, cur_len, retdest
+    %mload_trie_data
+    %stack (hash, cur_len, retdest) -> (retdest, hash, cur_len)
+    JUMP
+
+smt_hash_internal:
+global debug_hash_internal:
+    // stack: node, node_ptr, cur_len, retdest
+    POP
+    // stack: node_ptr, cur_len, retdest
+    SWAP1 %add_const(3) SWAP1
+    %increment
+    // stack: node_ptr+1, cur_len, retdest
+    DUP1
+    %mload_trie_data
+    %stack (left_child_ptr, node_ptr_plus_1, cur_len, retdest) -> (left_child_ptr, cur_len, smt_hash_internal_after_left, node_ptr_plus_1, retdest)
+    %jump(smt_hash)
+smt_hash_internal_after_left:
+global debug_hash_internal_after_left:
+    %stack (left_hash, cur_len, node_ptr_plus_1, retdest) -> (node_ptr_plus_1, left_hash, cur_len, retdest)
+    %increment
+    // stack: node_ptr+2, left_hash, cur_len, retdest
+    %mload_trie_data
+    %stack (right_child_ptr, left_hash, cur_len, retdest) -> (right_child_ptr, cur_len, smt_hash_internal_after_right, left_hash, retdest)
+    %jump(smt_hash)
+smt_hash_internal_after_right:
+global debug_hash_internal_after_right:
+    %stack (right_hash, cur_len, left_hash) -> (left_hash, right_hash, 0, cur_len)
+    POSEIDON
+    %stack (hash, cur_len, retdest) -> (retdest, hash, cur_len)
+    JUMP
+
+smt_hash_leaf:
+global debug_hash_leaf:
+    // stack: node_ptr, cur_len, retdest
+    SWAP1 %add_const(3) SWAP1
+    // stack: node_ptr, cur_len, retdest
+    %increment
+    // stack: node_ptr+1, cur_len, retdest
+    DUP1 %increment
+    // stack: node_ptr+2, node_ptr+1, cur_len, retdest
+    %mload_trie_data
+    // stack: value, node_ptr+1, cur_len, retdest
+    SWAP1
+    // stack: node_ptr+1, value, cur_len, retdest
+    %mload_trie_data
+    %stack (rem_key, value) -> (value, smt_hash_leaf_contd, rem_key)
+    %jump(hash_limbs)
+smt_hash_leaf_contd:
+    %stack (value_hash, rem_key) -> (rem_key, value_hash, 1)
+    POSEIDON
+    %stack (hash, cur_len, retdest) -> (retdest, hash, cur_len)
+    JUMP
diff --git a/evm_arithmetization/src/cpu/kernel/asm/smt/insert.asm b/evm_arithmetization/src/cpu/kernel/asm/smt/insert.asm
new file mode 100644
index 000000000..20589b083
--- /dev/null
+++ b/evm_arithmetization/src/cpu/kernel/asm/smt/insert.asm
@@ -0,0 +1,175 @@
+// Insert a key-value pair in the state SMT.
+global smt_insert_state:
+    // stack: key, value, retdest
+    DUP2 ISZERO %jumpi(insert_zero)
+    // stack: key, value, retdest
+    %stack (key, value) -> (key, value, smt_insert_state_after)
+    %split_key
+    // stack: k0, k1, k2, k3, value, smt_insert_state_after, retdest
+    PUSH 0
+    // stack: level, k0, k1, k2, k3, value, smt_insert_state_after, retdest
+    %mload_global_metadata(@GLOBAL_METADATA_STATE_TRIE_ROOT) // node_ptr
+    // stack: node_ptr, level, k0, k1, k2, k3, value, smt_insert_state_after, retdest
+    %jump(smt_insert)
+
+smt_insert_state_after:
+    // stack: root_ptr, retdest
+    %mstore_global_metadata(@GLOBAL_METADATA_STATE_TRIE_ROOT)
+    // stack: retdest
+    JUMP
+
+%macro smt_insert_state
+    %stack (key, value_ptr) -> (key, value_ptr, %%after)
+    %jump(smt_insert_state)
+%%after:
+%endmacro
+
+// Insert a key-value pair in the SMT at `trie_data[node_ptr]`.
+// Pseudocode:
+// ```
+// insert( HashNode { h }, key, value ) = if h == 0 then Leaf { key, value } else PANIC
+// insert( InternalNode { left, right }, key, value ) = if key&1 { insert( right, key>>1, value ) } else { insert( left, key>>1, value ) }
+// insert( Leaf { key', value' }, key, value ) = {
+//    let internal = new InternalNode;
+//    insert(internal, key', value');
+//    insert(internal, key, value);
+//    return internal;}
+// ```
+global smt_insert:
+    // stack: node_ptr, level, ks, value, retdest
+    DUP1 %mload_trie_data
+    // stack: node_type, node_ptr, level, ks, value, retdest
+    // Increment node_ptr, so it points to the node payload instead of its type.
+    SWAP1 %increment SWAP1
+    // stack: node_type, node_payload_ptr, level, ks, value, retdest
+
+    DUP1 %eq_const(@SMT_NODE_HASH)        %jumpi(smt_insert_hash)
+    DUP1 %eq_const(@SMT_NODE_INTERNAL)    %jumpi(smt_insert_internal)
+    DUP1 %eq_const(@SMT_NODE_LEAF)        %jumpi(smt_insert_leaf)
+    PANIC
+
+smt_insert_hash:
+    // stack: node_type, node_payload_ptr, level, ks, value, retdest
+    POP
+    // stack: node_payload_ptr, level, ks, value, retdest
+    %mload_trie_data
+    // stack: hash, level, ks, value, retdest
+    ISZERO %jumpi(smt_insert_empty)
+    PANIC // Trying to insert in a non-empty hash node.
+smt_insert_empty:
+    // stack: level, ks, value, retdest
+    POP
+    // stack: ks, value, retdest
+    %combine_key
+    // stack: key, value, retdest
+    %get_trie_data_size
+    // stack: index, key, value, retdest
+    PUSH @SMT_NODE_LEAF %append_to_trie_data
+    %stack (index, key, value) -> (key, value, index)
+    %append_to_trie_data // key
+    %append_to_trie_data // value
+    // stack: index, retdest
+    SWAP1 JUMP
+
+smt_insert_internal:
+    // stack: node_type, node_payload_ptr, level, ks, value, retdest
+    POP
+    // stack: node_payload_ptr, level, ks, value, retdest
+    DUP2 %and_const(3) // level mod 4
+    // stack: level%4, node_payload_ptr, level, ks, value, retdest
+    DUP1 %eq_const(0) %jumpi(smt_insert_internal_0)
+    DUP1 %eq_const(1) %jumpi(smt_insert_internal_1)
+    DUP1 %eq_const(2) %jumpi(smt_insert_internal_2)
+         %eq_const(3) %jumpi(smt_insert_internal_3)
+    PANIC
+smt_insert_internal_0:
+    // stack: level%4, node_payload_ptr, level, ks, value, retdest
+    %stack (level_mod_4, node_payload_ptr, level, k0, k1, k2, k3 ) -> (k0, node_payload_ptr, level, k0, k1, k2, k3 )
+    %pop_bit
+    %stack (bit, newk0, node_payload_ptr, level, k0, k1, k2, k3 ) -> (bit, node_payload_ptr, level, newk0, k1, k2, k3 )
+    %jump(smt_insert_internal_contd)
+smt_insert_internal_1:
+    // stack: level%4, node_payload_ptr, level, ks, value, retdest
+    %stack (level_mod_4, node_payload_ptr, level, k0, k1, k2, k3 ) -> (k1, node_payload_ptr, level, k0, k1, k2, k3 )
+    %pop_bit
+    %stack (bit, newk1, node_payload_ptr, level, k0, k1, k2, k3 ) -> (bit, node_payload_ptr, level, k0, newk1, k2, k3 )
+    %jump(smt_insert_internal_contd)
+smt_insert_internal_2:
+    // stack: level%4, node_payload_ptr, level, ks, value, retdest
+    %stack (level_mod_4, node_payload_ptr, level, k0, k1, k2, k3 ) -> (k2, node_payload_ptr, level, k0, k1, k2, k3 )
+    %pop_bit
+    %stack (bit, newk2, node_payload_ptr, level, k0, k1, k2, k3 ) -> (bit, node_payload_ptr, level, k0, k1, newk2, k3 )
+    %jump(smt_insert_internal_contd)
+smt_insert_internal_3:
+    // stack: level%4, node_payload_ptr, level, ks, value, retdest
+    %stack (node_payload_ptr, level, k0, k1, k2, k3 ) -> (k3, node_payload_ptr, level, k0, k1, k2, k3 )
+    %pop_bit
+    %stack (bit, newk3, node_payload_ptr, level, k0, k1, k2, k3 ) -> (bit, node_payload_ptr, level, k0, k1, k2, newk3 )
+    %jump(smt_insert_internal_contd)
+smt_insert_internal_contd:
+    // stack: bit, node_payload_ptr, level, ks, value, retdest
+    DUP2 ADD
+    // stack: child_ptr_ptr, node_payload_ptr, level, ks, value, retdest
+    DUP1 %mload_trie_data
+    // stack: child_ptr, child_ptr_ptr, node_payload_ptr, level, ks, value, retdest
+    SWAP3 %increment SWAP3
+    %stack (child_ptr, child_ptr_ptr, node_payload_ptr, level_plus_1, k0, k1, k2, k3, value, retdest) ->
+            (child_ptr, level_plus_1, k0, k1, k2, k3, value, smt_insert_internal_after, child_ptr_ptr, node_payload_ptr, retdest)
+    %jump(smt_insert)
+
+smt_insert_internal_after:
+    // stack: new_node_ptr, child_ptr_ptr, node_payload_ptr, retdest
+    SWAP1 %mstore_trie_data
+    // stack: node_payload_ptr, retdest
+    %decrement
+    SWAP1 JUMP
+
+smt_insert_leaf:
+    // stack: node_type, node_payload_ptr, level, ks, value, retdest
+    POP
+    %stack (node_payload_ptr, level, k0, k1, k2, k3, value) -> (k0, k1, k2, k3, node_payload_ptr, level, k0, k1, k2, k3, value)
+    %combine_key
+    // stack: rem_key, node_payload_ptr, level, ks, value, retdest
+    DUP2 %mload_trie_data
+    // stack: existing_key, rem_key, node_payload_ptr, level, ks, value, retdest
+    DUP2 DUP2 EQ %jumpi(smt_insert_leaf_same_key)
+    // stack: existing_key, rem_key, node_payload_ptr, level, ks, value, retdest
+    // We create an internal node with two empty children, and then we insert the two leaves.
+    %get_trie_data_size
+    // stack: index, existing_key, rem_key, node_payload_ptr, level, ks, value, retdest
+    PUSH @SMT_NODE_INTERNAL %append_to_trie_data
+    PUSH 0 %append_to_trie_data // Empty hash node
+    PUSH 0 %append_to_trie_data // Empty hash node
+    // stack: index, existing_key, rem_key, node_payload_ptr, level, ks, value, retdest
+    SWAP1 %split_key
+    // stack: existing_k0, existing_k1, existing_k2, existing_k3, index, rem_key, node_payload_ptr, level, ks, value, retdest
+    DUP7 %increment %mload_trie_data
+    // stack: existing_value, existing_k0, existing_k1, existing_k2, existing_k3, index, rem_key, node_payload_ptr, level, ks, value, retdest
+    DUP9
+    %stack (level, existing_value, existing_k0, existing_k1, existing_k2, existing_k3, index) -> (index, level, existing_k0, existing_k1, existing_k2, existing_k3, existing_value, after_first_leaf)
+    %jump(smt_insert)
+after_first_leaf:
+    // stack: internal_ptr, rem_key, node_payload_ptr, level, ks, value, retdest
+    %stack (internal_ptr, rem_key, node_payload_ptr, level, k0, k1, k2, k3, value) -> (internal_ptr, level, k0, k1, k2, k3, value)
+    %jump(smt_insert)
+
+smt_insert_leaf_same_key:
+    // stack: existing_key, rem_key, node_payload_ptr, level, ks, value, retdest
+    %pop2
+    %stack (node_payload_ptr, level, k0, k1, k2, k3, value) -> (node_payload_ptr, value, node_payload_ptr)
+    %increment %mstore_trie_data
+    // stack: node_payload_ptr, retdest
+    %decrement
+    // stack: node_ptr, retdest
+    SWAP1 JUMP
+
+insert_zero:
+    // stack: key, value, retdest
+    DUP1 %smt_read_state %mload_trie_data %jumpi(delete)
+    // stack: key, value, retdest
+    %pop2 JUMP
+delete:
+    // stack: key, value, retdest
+    %smt_delete_state
+    // stack: value, retdest
+    POP JUMP
diff --git a/evm_arithmetization/src/cpu/kernel/asm/smt/keys.asm b/evm_arithmetization/src/cpu/kernel/asm/smt/keys.asm
new file mode 100644
index 000000000..0d8b09013
--- /dev/null
+++ b/evm_arithmetization/src/cpu/kernel/asm/smt/keys.asm
@@ -0,0 +1,131 @@
+/// See `smt_trie::keys.rs` for documentation.
+
+// addr = sum_{0<=i<5} a_i << (32i)
+%macro key_balance
+    // stack: addr
+    PUSH 0x100000000
+    // stack: u32max, addr
+    DUP1 DUP3 MOD
+    // stack: a_0, u32max, addr
+    DUP2 DUP4 %shr_const(32) MOD %shl_const(64) ADD
+    // stack: a_0 + a_1<<64, u32max, addr
+    DUP2 DUP4 %shr_const(64) MOD %shl_const(128) ADD
+    // stack: a_0 + a_1<<64 + a_2<<128, u32max, addr
+    DUP2 DUP4 %shr_const(96) MOD %shl_const(192) ADD
+    // stack: a_0 + a_1<<64 + a_2<<128 + a_3<<192, u32max, addr
+    SWAP2 %shr_const(128)
+    // stack: a_4, u32max, a_0 + a_1<<64 + a_2<<128 + a_3<<192
+    %stack (y, u32max, x) -> (x, y, @POSEIDON_HASH_ZEROS)
+    POSEIDON
+%endmacro
+
+// addr = sum_{0<=i<5} a_i << (32i)
+%macro key_nonce
+    // stack: addr
+    PUSH 0x100000000
+    // stack: u32max, addr
+    DUP1 DUP3 MOD
+    // stack: a_0, u32max, addr
+    DUP2 DUP4 %shr_const(32) MOD %shl_const(64) ADD
+    // stack: a_0 + a_1<<64, u32max, addr
+    DUP2 DUP4 %shr_const(64) MOD %shl_const(128) ADD
+    // stack: a_0 + a_1<<64 + a_2<<128, u32max, addr
+    DUP2 DUP4 %shr_const(96) MOD %shl_const(192) ADD
+    // stack: a_0 + a_1<<64 + a_2<<128 + a_3<<192, u32max, addr
+    SWAP2 %shr_const(128)
+    // stack: a_4, u32max, a_0 + a_1<<64 + a_2<<128 + a_3<<192
+    %add_const(0x100000000000000000000000000000000) // SMT_KEY_NONCE (=1) << 128
+    %stack (y, u32max, x) -> (x, y, @POSEIDON_HASH_ZEROS)
+    POSEIDON
+%endmacro
+
+// addr = sum_{0<=i<5} a_i << (32i)
+%macro key_code
+    // stack: addr
+    PUSH 0x100000000
+    // stack: u32max, addr
+    DUP1 DUP3 MOD
+    // stack: a_0, u32max, addr
+    DUP2 DUP4 %shr_const(32) MOD %shl_const(64) ADD
+    // stack: a_0 + a_1<<64, u32max, addr
+    DUP2 DUP4 %shr_const(64) MOD %shl_const(128) ADD
+    // stack: a_0 + a_1<<64 + a_2<<128, u32max, addr
+    DUP2 DUP4 %shr_const(96) MOD %shl_const(192) ADD
+    // stack: a_0 + a_1<<64 + a_2<<128 + a_3<<192, u32max, addr
+    SWAP2 %shr_const(128)
+    // stack: a_4, u32max, a_0 + a_1<<64 + a_2<<128 + a_3<<192
+    %add_const(0x200000000000000000000000000000000) // SMT_KEY_CODE (=2) << 128
+    %stack (y, u32max, x) -> (x, y, @POSEIDON_HASH_ZEROS)
+    POSEIDON
+%endmacro
+
+// addr = sum_{0<=i<5} a_i << (32i)
+%macro key_code_length
+    // stack: addr
+    PUSH 0x100000000
+    // stack: u32max, addr
+    DUP1 DUP3 MOD
+    // stack: a_0, u32max, addr
+    DUP2 DUP4 %shr_const(32) MOD %shl_const(64) ADD
+    // stack: a_0 + a_1<<64, u32max, addr
+    DUP2 DUP4 %shr_const(64) MOD %shl_const(128) ADD
+    // stack: a_0 + a_1<<64 + a_2<<128, u32max, addr
+    DUP2 DUP4 %shr_const(96) MOD %shl_const(192) ADD
+    // stack: a_0 + a_1<<64 + a_2<<128 + a_3<<192, u32max, addr
+    SWAP2 %shr_const(128)
+    // stack: a_4, u32max, a_0 + a_1<<64 + a_2<<128 + a_3<<192
+    %add_const(0x400000000000000000000000000000000) // SMT_KEY_CODE_LENGTH (=4) << 128
+    %stack (y, u32max, x) -> (x, y, @POSEIDON_HASH_ZEROS)
+    POSEIDON
+%endmacro
+
+// addr = sum_{0<=i<5} a_i << (32i)
+%macro key_storage
+    %stack (addr, slot) -> (slot, %%after, addr)
+    %jump(hash_limbs)
+%%after:
+    // stack: capacity, addr
+    SWAP1
+    // stack: addr, capacity
+    PUSH 0x100000000
+    // stack: u32max, addr, capacity
+    DUP1 DUP3 MOD
+    // stack: a_0, u32max, addr
+    DUP2 DUP4 %shr_const(32) MOD %shl_const(64) ADD
+    // stack: a_0 + a_1<<64, u32max, addr
+    DUP2 DUP4 %shr_const(64) MOD %shl_const(128) ADD
+    // stack: a_0 + a_1<<64 + a_2<<128, u32max, addr
+    DUP2 DUP4 %shr_const(96) MOD %shl_const(192) ADD
+    // stack: a_0 + a_1<<64 + a_2<<128 + a_3<<192, u32max, addr
+    SWAP2 %shr_const(128)
+    // stack: a_4, u32max, a_0 + a_1<<64 + a_2<<128 + a_3<<192
+    %add_const(0x300000000000000000000000000000000) // SMT_KEY_STORAGE (=3) << 128
+    %stack (y, u32max, x, capacity) -> (x, y, capacity)
+    POSEIDON
+%endmacro
+
+// slot = sum_{0<=i<8} s_i << (32i)
+global hash_limbs:
+    // stack: slot, retdest
+    PUSH 0x100000000
+    // stack: u32max, slot, retdest
+    DUP1 DUP3 MOD
+    // stack: s_0, u32max, slot
+    DUP2 DUP4 %shr_const(32) MOD %shl_const(64) ADD
+    // stack: s_0 + s_1<<64, u32max, slot
+    DUP2 DUP4 %shr_const(64) MOD %shl_const(128) ADD
+    // stack: s_0 + s_1<<64 + s_2<<128, u32max, slot
+    DUP2 DUP4 %shr_const(96) MOD %shl_const(192) ADD
+    // stack: s_0 + s_1<<64 + s_2<<128 + s_3<<192, u32max, slot
+    DUP2 DUP4 %shr_const(128) MOD
+    // stack: s_4, s_0 + s_1<<64 + s_2<<128 + s_3<<192, u32max, slot
+    DUP3 DUP5 %shr_const(160) MOD %shl_const(64) ADD
+    // stack: s_4 + s_5<<64, s_0 + s_1<<64 + s_2<<128 + s_3<<192, u32max, slot
+    DUP3 DUP5 %shr_const(192) MOD %shl_const(128) ADD
+    // stack: s_4 + s_5<<64 + s_6<<128, s_0 + s_1<<64 + s_2<<128 + s_3<<192, u32max, slot
+    DUP3 DUP5 %shr_const(224) MOD %shl_const(192) ADD
+    // stack: s_4 + s_5<<64 + s_6<<128 + s_7<<192, s_0 + s_1<<64 + s_2<<128 + s_3<<192, u32max, slot
+    %stack (b, a, u32max, slot) -> (a, b, 0)
+    POSEIDON
+    // stack: hash, retdest
+    SWAP1 JUMP
diff --git a/evm_arithmetization/src/cpu/kernel/asm/smt/read.asm b/evm_arithmetization/src/cpu/kernel/asm/smt/read.asm
new file mode 100644
index 000000000..620db38dc
--- /dev/null
+++ b/evm_arithmetization/src/cpu/kernel/asm/smt/read.asm
@@ -0,0 +1,111 @@
+// Given a key, return a pointer to the associated SMT entry.
+// Returns 0 if the key is not in the SMT.
+global smt_read_state:
+    // stack: key, retdest
+    %split_key
+    // stack: k0, k1, k2, k3, retdest
+    PUSH 0
+    // stack: level, k0, k1, k2, k3, retdest
+    %mload_global_metadata(@GLOBAL_METADATA_STATE_TRIE_ROOT) // node_ptr
+    // stack: node_ptr, level, k0, k1, k2, k3, retdest
+    %jump(smt_read)
+
+// Convenience macro to call smt_read_state and return where we left off.
+%macro smt_read_state
+    %stack (key) -> (key, %%after)
+    %jump(smt_read_state)
+%%after:
+%endmacro
+
+// Return a pointer to the data at the given key in the SMT at `trie_data[node_ptr]`.
+// Pseudocode:
+// ```
+// read( HashNode { h }, key ) = if h == 0 then 0 else PANIC
+// read( InternalNode { left, right }, key ) = if key&1 { read( right, key>>1 ) } else { read( left, key>>1 ) }
+// read( Leaf { rem_key', value }, key ) = if rem_key == rem_key' then &value else 0
+// ```
+global smt_read:
+    // stack: node_ptr, level, ks, retdest
+    DUP1 %mload_trie_data
+    // stack: node_type, node_ptr, level, ks, retdest
+    // Increment node_ptr, so it points to the node payload instead of its type.
+    SWAP1 %increment SWAP1
+    // stack: node_type, node_payload_ptr, level, ks, retdest
+
+    DUP1 %eq_const(@SMT_NODE_HASH)      %jumpi(smt_read_hash)
+    DUP1 %eq_const(@SMT_NODE_INTERNAL)  %jumpi(smt_read_internal)
+    %eq_const(@SMT_NODE_LEAF)           %jumpi(smt_read_leaf)
+    PANIC
+
+smt_read_hash:
+    // stack: node_type, node_payload_ptr, level, ks, retdest
+    POP
+    // stack: node_payload_ptr, level, ks, retdest
+    %mload_trie_data
+    // stack: hash, level, ks, retdest
+    ISZERO %jumpi(smt_read_empty)
+    PANIC // Trying to read a non-empty hash node. Should never happen.
+
+smt_read_empty:
+    %stack (level, k0, k1, k2, k3, retdest) -> (retdest, 0)
+    JUMP
+
+smt_read_internal:
+    // stack: node_type, node_payload_ptr, level, ks, retdest
+    POP
+    // stack: node_payload_ptr, level, ks, retdest
+    DUP2 %and_const(3) // level mod 4
+    // stack: level%4, node_payload_ptr, level, ks, retdest
+    DUP1 %eq_const(0) %jumpi(smt_read_internal_0)
+    DUP1 %eq_const(1) %jumpi(smt_read_internal_1)
+    DUP1 %eq_const(2) %jumpi(smt_read_internal_2)
+    DUP1 %eq_const(3) %jumpi(smt_read_internal_3)
+    PANIC
+smt_read_internal_0:
+    %stack (level_mod_4, node_payload_ptr, level, k0, k1, k2, k3 ) -> (k0, node_payload_ptr, level, k0, k1, k2, k3 )
+    %pop_bit
+    %stack (bit, newk0, node_payload_ptr, level, k0, k1, k2, k3 ) -> (bit, node_payload_ptr, level, newk0, k1, k2, k3 )
+    %jump(smt_read_internal_contd)
+smt_read_internal_1:
+    %stack (level_mod_4, node_payload_ptr, level, k0, k1, k2, k3 ) -> (k1, node_payload_ptr, level, k0, k1, k2, k3 )
+    %pop_bit
+    %stack (bit, newk1, node_payload_ptr, level , k0, k1, k2, k3 ) -> (bit, node_payload_ptr, level, k0, newk1, k2, k3 )
+    %jump(smt_read_internal_contd)
+smt_read_internal_2:
+    %stack (level_mod_4, node_payload_ptr, level, k0, k1, k2, k3 ) -> (k2, node_payload_ptr, level, k0, k1, k2, k3 )
+    %pop_bit
+    %stack (bit, newk2, node_payload_ptr, level, k0, k1, k2, k3 ) -> (bit, node_payload_ptr, level, k0, k1, newk2, k3 )
+    %jump(smt_read_internal_contd)
+smt_read_internal_3:
+    %stack (level_mod_4, node_payload_ptr, level, k0, k1, k2, k3 ) -> (k3, node_payload_ptr, level, k0, k1, k2, k3 )
+    %pop_bit
+    %stack (bit, newk3, node_payload_ptr, level, k0, k1, k2, k3 ) -> (bit, node_payload_ptr, level, k0, k1, k2, newk3 )
+smt_read_internal_contd:
+    // stack: bit, node_payload_ptr, level, k0, k1, k2, k3, retdest
+    ADD
+    // stack: child_ptr_ptr, level, k0, k1, k2, k3, retdest
+    %mload_trie_data
+    // stack: child_ptr, level, k0, k1, k2, k3, retdest
+    SWAP1 %increment SWAP1
+    // stack: child_ptr, level+1, k0, k1, k2, k3, retdest
+    %jump(smt_read)
+
+smt_read_leaf:
+    // stack: node_payload_ptr, level, ks, retdest
+    DUP1 %mload_trie_data
+    // stack: rem_key, node_payload_ptr, level, ks, retdest
+    SWAP1
+    // stack: node_payload_ptr, rem_key, level, ks, retdest
+    %increment
+    %stack (value_ptr, rem_key, level, k0, k1, k2, k3) -> (k0, k1, k2, k3, rem_key, value_ptr)
+    %combine_key
+    // stack: this_rem_key, rem_key, value_ptr, retdest
+    EQ %jumpi(smt_read_existing_leaf)
+smt_read_non_existing_leaf:
+    %stack (value_ptr, retdest) -> (retdest, 0)
+    JUMP
+
+smt_read_existing_leaf:
+global debug_smt_existing_leaf:
+    // stack: value_ptr, retdest
+    SWAP1 JUMP
diff --git a/evm_arithmetization/src/cpu/kernel/asm/smt/utils.asm b/evm_arithmetization/src/cpu/kernel/asm/smt/utils.asm
new file mode 100644
index 000000000..4f8c2832e
--- /dev/null
+++ b/evm_arithmetization/src/cpu/kernel/asm/smt/utils.asm
@@ -0,0 +1,129 @@
+// Input: x
+// Output: (x&1, x>>1)
+%macro pop_bit
+    // stack: key
+    DUP1 %shr_const(1)
+    // stack: key>>1, key
+    SWAP1 %mod_const(2)
+    // stack: key&1, key>>1
+%endmacro
+
+// Returns a non-zero value if the node is non-empty.
+%macro is_non_empty_node
+    // stack: node_ptr
+    DUP1 %mload_trie_data %jumpi(%%end) // If the node is not a hash node, node_ptr is non-zero.
+    // The node is a hash node
+    // stack: node_ptr
+    %increment %mload_trie_data
+    // stack: hash
+%%end:
+%endmacro
+
+// Input: key = k0 + k1.2^64 + k2.2^128 + k3.2^192, with 0<=ki<2^64.
+// Output: (k0, k1, k2, k3)
+%macro split_key
+    // stack: key
+    DUP1 %shr_const(128) %mod_const(0x10000000000000000)
+    // stack: k2, key
+    DUP2 %shr_const(64) %mod_const(0x10000000000000000)
+    // stack: k1, k2, key
+    DUP3 %shr_const(192)
+    // stack: k3, k1, k2, key
+    SWAP3 %mod_const(0x10000000000000000)
+    // stack: k0, k1, k2, k3
+%endmacro
+
+// Input: (k0, k1, k2, k3)
+// Output: k0 + k1.2^64 + k2.2^128 + k3.2^192
+%macro combine_key
+    // stack: k0, k1, k2, k3
+    SWAP1 %shl_const(64) ADD
+    // stack: k0 + k1<<64, k2, k3
+    SWAP1 %shl_const(128) ADD
+    // stack: k0 + k1<<64 + k2<<128, k3
+    SWAP1 %shl_const(192) ADD
+    // stack: k0 + k1<<64 + k2<<128 + k3<<192
+%endmacro
+
+
+// Pseudocode:
+// ```
+// def recombine_key(key, bit, level):
+//   k0, k1, k2, k3 = [(key>>(64*i))&(2**64-1) for i in range(4)]
+//   match level%4:
+//     0 => k0 = 2*k0 + bit
+//     1 => k1 = 2*k1 + bit
+//     2 => k2 = 2*k2 + bit
+//     3 => k3 = 2*k3 + bit
+//   return k0 + (k1<<64) + (k2<<128) + (k3<<192)
+// ```
+%macro recombine_key
+    // stack: key, bit, level
+    SWAP1
+    // stack: bit, key, level
+    SWAP2
+    // stack: level, key, bit
+    %mod_const(4)
+    // stack: level%4, key, bit
+    DUP1 %eq_const(0) %jumpi(%%recombine_key_0)
+    DUP1 %eq_const(1) %jumpi(%%recombine_key_1)
+    DUP1 %eq_const(2) %jumpi(%%recombine_key_2)
+    DUP1 %eq_const(3) %jumpi(%%recombine_key_3)
+    PANIC
+%%recombine_key_0:
+    // stack: level%4, key, bit
+    POP
+    // stack: key, bit
+    %split_key
+    // stack: k0, k1, k2, k3, bit
+    %shl_const(1)
+    // stack: k0<<1, k1, k2, k3, bit
+    DUP5 ADD
+    // stack: k0<<1 + bit, k1, k2, k3, bit
+    %combine_key
+    %stack (newkey, bit) -> (newkey)
+    %jump(%%after)
+%%recombine_key_1:
+    // stack: level%4, key, bit
+    POP
+    // stack: key, bit
+    %split_key
+    // stack: k0, k1, k2, k3, bit
+    DUP2 %shl_const(1)
+    // stack: k1<<1, k0, k1, k2, k3, bit
+    DUP6 ADD
+    // stack: k1<<1 + bit, k0, k1, k2, k3, bit
+    SWAP2 POP
+    %combine_key
+    %stack (newkey, bit) -> (newkey)
+    %jump(%%after)
+%%recombine_key_2:
+    // stack: key, bit
+    POP
+    // stack: key, bit
+    %split_key
+    // stack: k0, k1, k2, k3, bit
+    DUP3 %shl_const(1)
+    // stack: k2<<1, k0, k1, k2, k3, bit
+    DUP6 ADD
+    // stack: k2<<1 + bit, k0, k1, k2, k3, bit
+    SWAP3 POP
+    %combine_key
+    %stack (newkey, bit) -> (newkey)
+    %jump(%%after)
+%%recombine_key_3:
+    // stack: key, bit
+    POP
+    // stack: key, bit
+    %split_key
+    // stack: k0, k1, k2, k3, bit
+    DUP4 %shl_const(1)
+    // stack: k3<<1, k0, k1, k2, k3, bit
+    DUP6 ADD
+    // stack: k3<<1 + bit, k0, k1, k2, k3, bit
+    SWAP4 POP
+    %combine_key
+    %stack (newkey, bit) -> (newkey)
+%%after:
+    // stack: newkey
+%endmacro
diff --git a/evm_arithmetization/src/cpu/kernel/asm/transactions/common_decoding.asm b/evm_arithmetization/src/cpu/kernel/asm/transactions/common_decoding.asm
index 6ee92ca2b..2098c6150 100644
--- a/evm_arithmetization/src/cpu/kernel/asm/transactions/common_decoding.asm
+++ b/evm_arithmetization/src/cpu/kernel/asm/transactions/common_decoding.asm
@@ -225,10 +225,10 @@ decode_and_store_access_list_finish:
 %endmacro
 
 insert_accessed_storage_keys_with_original_value:
-    %stack (addr, key, retdest) -> (key, addr, after_read, addr, key, retdest)
+    %stack (addr, key, retdest) -> (addr, key, after_read, addr, key, retdest)
     %jump(sload_with_addr)
 after_read:
-    %stack (value, addr, key, retdest) -> ( addr, key, value, retdest)
+    %stack (value, addr, key, retdest) -> (addr, key, value, retdest)
     %insert_accessed_storage_keys
     // stack: cold_access, value_ptr, value, retdest
     SWAP2
@@ -239,7 +239,7 @@ after_read:
     JUMP
 
 sload_with_addr:
-    %read_storage_linked_list_w_addr
+    %read_slot_from_addr
     // stack: value, retdest
     SWAP1
     JUMP
diff --git a/evm_arithmetization/src/cpu/kernel/asm/util/keccak.asm b/evm_arithmetization/src/cpu/kernel/asm/util/keccak.asm
index dceb7b195..70fabb899 100644
--- a/evm_arithmetization/src/cpu/kernel/asm/util/keccak.asm
+++ b/evm_arithmetization/src/cpu/kernel/asm/util/keccak.asm
@@ -28,7 +28,7 @@ global sys_keccak256:
 sys_keccak256_empty:
     // stack: static_gas, kexit_info, offset, len
     %charge_gas
-    %stack (kexit_info, offset, len) -> (kexit_info, @EMPTY_STRING_HASH)
+    %stack (kexit_info, offset, len) -> (kexit_info, @EMPTY_STRING_KECCAK_HASH)
     EXIT_KERNEL
 
 // Computes Keccak256(input_word). Clobbers @SEGMENT_KERNEL_GENERAL.
diff --git a/evm_arithmetization/src/cpu/kernel/assembler.rs b/evm_arithmetization/src/cpu/kernel/assembler.rs
index 8c4fb2fb0..4476a0c51 100644
--- a/evm_arithmetization/src/cpu/kernel/assembler.rs
+++ b/evm_arithmetization/src/cpu/kernel/assembler.rs
@@ -457,7 +457,7 @@ fn push_target_size(target: &PushTarget) -> u8 {
     match target {
         PushTarget::Literal(n) => u256_to_trimmed_be_bytes(n).len() as u8,
         PushTarget::Label(_) => BYTES_PER_OFFSET,
-        PushTarget::MacroLabel(v) => panic!("Macro label not in a macro: {v}"),
+        PushTarget::MacroLabel(_) => BYTES_PER_OFFSET,
         PushTarget::MacroVar(v) => panic!("Variable not in a macro: {v}"),
         PushTarget::Constant(c) => panic!("Constant wasn't inlined: {c}"),
     }
diff --git a/evm_arithmetization/src/cpu/kernel/constants/global_metadata.rs b/evm_arithmetization/src/cpu/kernel/constants/global_metadata.rs
index 1839ec33d..ec94ddbf5 100644
--- a/evm_arithmetization/src/cpu/kernel/constants/global_metadata.rs
+++ b/evm_arithmetization/src/cpu/kernel/constants/global_metadata.rs
@@ -113,10 +113,13 @@ pub(crate) enum GlobalMetadata {
 
     /// Address where the base fee to be burnt is sent.
     BurnAddr,
+
+    /// Number of used storage slots in newly created contracts.
+    NewStorageSlotsLen,
 }
 
 impl GlobalMetadata {
-    pub(crate) const COUNT: usize = 54;
+    pub(crate) const COUNT: usize = 55;
 
     /// Unscales this virtual offset by their respective `Segment` value.
     pub(crate) const fn unscale(&self) -> usize {
@@ -179,6 +182,7 @@ impl GlobalMetadata {
             Self::TransientStorageLen,
             Self::BlobVersionedHashesLen,
             Self::BurnAddr,
+            Self::NewStorageSlotsLen,
         ]
     }
 
@@ -245,6 +249,7 @@ impl GlobalMetadata {
             Self::TransientStorageLen => "GLOBAL_METADATA_TRANSIENT_STORAGE_LEN",
             Self::BlobVersionedHashesLen => "GLOBAL_METADATA_BLOB_VERSIONED_HASHES_LEN",
             Self::BurnAddr => "GLOBAL_METADATA_BURN_ADDR",
+            Self::NewStorageSlotsLen => "GLOBAL_METADATA_NEW_STORAGE_SLOTS_LEN",
         }
     }
 }
diff --git a/evm_arithmetization/src/cpu/kernel/constants/mod.rs b/evm_arithmetization/src/cpu/kernel/constants/mod.rs
index 91c2a0a77..4b4df6304 100644
--- a/evm_arithmetization/src/cpu/kernel/constants/mod.rs
+++ b/evm_arithmetization/src/cpu/kernel/constants/mod.rs
@@ -2,19 +2,20 @@ use std::collections::HashMap;
 
 use ethereum_types::{Address, H160, H256, U256};
 use hex_literal::hex;
+use smt_type::PartialSmtType;
 
 use crate::cpu::kernel::constants::context_metadata::ContextMetadata;
 use crate::cpu::kernel::constants::global_metadata::GlobalMetadata;
 use crate::cpu::kernel::constants::journal_entry::JournalEntry;
 use crate::cpu::kernel::constants::trie_type::PartialTrieType;
 use crate::cpu::kernel::constants::txn_fields::NormalizedTxnField;
-use crate::generation::mpt::AccountRlp;
 use crate::memory::segments::Segment;
 
 pub(crate) mod context_metadata;
 mod exc_bitfields;
 pub(crate) mod global_metadata;
 pub(crate) mod journal_entry;
+pub(crate) mod smt_type;
 pub(crate) mod trie_type;
 pub(crate) mod txn_fields;
 
@@ -68,6 +69,7 @@ pub(crate) fn evm_constants() -> HashMap<String, U256> {
 
     c.insert(MAX_NONCE.0.into(), U256::from(MAX_NONCE.1));
     c.insert(CALL_STACK_LIMIT.0.into(), U256::from(CALL_STACK_LIMIT.1));
+    c.insert(POSEIDON_HASH_ZEROS.0.into(), POSEIDON_HASH_ZEROS.1);
     c.insert(
         MAX_RLP_PREFIX_SIZE.0.into(),
         U256::from(MAX_RLP_PREFIX_SIZE.1),
@@ -135,6 +137,9 @@ pub(crate) fn evm_constants() -> HashMap<String, U256> {
     for trie_type in PartialTrieType::all() {
         c.insert(trie_type.var_name().into(), (trie_type as u32).into());
     }
+    for trie_type in PartialSmtType::all() {
+        c.insert(trie_type.var_name().into(), (trie_type as u32).into());
+    }
     for entry in JournalEntry::all() {
         c.insert(entry.var_name().into(), (entry as u32).into());
     }
@@ -177,10 +182,10 @@ const MISC_CONSTANTS: [(&str, [u8; 32]); 4] = [
     ),
 ];
 
-const HASH_CONSTANTS: [(&str, [u8; 32]); 2] = [
+const HASH_CONSTANTS: [(&str, [u8; 32]); 3] = [
     // Hash of an empty string: keccak(b'').hex()
     (
-        "EMPTY_STRING_HASH",
+        "EMPTY_STRING_KECCAK_HASH",
         hex!("c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470"),
     ),
     // Hash of an empty node: keccak(rlp.encode(b'')).hex()
@@ -188,6 +193,10 @@ const HASH_CONSTANTS: [(&str, [u8; 32]); 2] = [
         "EMPTY_NODE_HASH",
         hex!("56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421"),
     ),
+    (
+        "EMPTY_STRING_POSEIDON_HASH",
+        hex!("3baed9289a384f6c1c05d92b56c801c2d2e2a7050d6c16538b814fa186835c79"),
+    ),
 ];
 
 const EC_CONSTANTS: [(&str, [u8; 32]); 25] = [
@@ -386,6 +395,16 @@ const CODE_SIZE_LIMIT: [(&str, u64); 3] = [
 const MAX_NONCE: (&str, u64) = ("MAX_NONCE", 0xffffffffffffffff);
 const CALL_STACK_LIMIT: (&str, u64) = ("CALL_STACK_LIMIT", 1024);
 
+const POSEIDON_HASH_ZEROS: (&str, U256) = (
+    "POSEIDON_HASH_ZEROS",
+    U256([
+        4330397376401421145,
+        14124799381142128323,
+        8742572140681234676,
+        14345658006221440202,
+    ]),
+);
+
 // 9 bytes, largest possible RLP prefix in our MPTs.
 const MAX_RLP_PREFIX_SIZE: (&str, u8) = ("MAX_RLP_PREFIX_SIZE", 9);
 // Address where RLP encoding generally starts.
@@ -394,12 +413,15 @@ const MAX_RLP_PREFIX_SIZE: (&str, u8) = ("MAX_RLP_PREFIX_SIZE", 9);
 pub(crate) const INITIAL_RLP_ADDR: (&str, usize) =
     ("INITIAL_RLP_ADDR", Segment::RlpRaw as usize + 1);
 
-const LINKED_LISTS_CONSTANTS: [(&str, u16); 5] = [
+const LINKED_LISTS_CONSTANTS: [(&str, u16); 8] = [
     ("ACCOUNTS_LINKED_LISTS_NODE_SIZE", 4),
     ("STORAGE_LINKED_LISTS_NODE_SIZE", 5),
+    ("STATE_LINKED_LISTS_NODE_SIZE", 4),
     ("ACCOUNTS_NEXT_NODE_PTR", 3),
     ("STORAGE_NEXT_NODE_PTR", 4),
+    ("STATE_NEXT_NODE_PTR", 3),
     ("STORAGE_COPY_PAYLOAD_PTR", 3),
+    ("STATE_COPY_PAYLOAD_PTR", 2),
 ];
 
 /// Cancun-related constants
@@ -408,6 +430,7 @@ const LINKED_LISTS_CONSTANTS: [(&str, u16); 5] = [
 pub mod cancun_constants {
 
     use super::*;
+    use crate::generation::mpt::MptAccount;
 
     pub const BLOB_BASE_FEE_UPDATE_FRACTION: U256 = U256([0x32f0ed, 0, 0, 0]);
 
@@ -449,11 +472,12 @@ pub mod cancun_constants {
         "BEACON_ROOTS_CONTRACT_STATE_KEY",
         *BEACON_ROOTS_CONTRACT_ADDRESS_HASHED.as_fixed_bytes(),
     );
+    pub const BEACON_ROOTS_CONTRACT_CODE_LEN_U256: U256 = U256([0, 0, 0, 97]);
     pub const BEACON_ROOTS_CONTRACT_CODE: [u8; 97] = hex!("3373fffffffffffffffffffffffffffffffffffffffe14604d57602036146024575f5ffd5b5f35801560495762001fff810690815414603c575f5ffd5b62001fff01545f5260205ff35b5f5ffd5b62001fff42064281555f359062001fff015500");
     pub const BEACON_ROOTS_CONTRACT_CODE_HASH: [u8; 32] =
         hex!("f57acd40259872606d76197ef052f3d35588dadf919ee1f0e3cb9b62d3f4b02c");
 
-    pub const BEACON_ROOTS_ACCOUNT: AccountRlp = AccountRlp {
+    pub const BEACON_ROOTS_ACCOUNT: MptAccount = MptAccount {
         nonce: U256::zero(),
         balance: U256::zero(),
         // Storage root for this account at genesis.
@@ -474,6 +498,7 @@ pub mod cancun_constants {
 
 pub mod global_exit_root {
     use super::*;
+    use crate::generation::mpt::MptAccount;
 
     /// Taken from <https://github.com/0xPolygonHermez/cdk-erigon/blob/61f0b6912055c73f6879ea7e9b5bac22ea5fc85c/zk/utils/global_exit_root.go#L16>.
     pub const GLOBAL_EXIT_ROOT_MANAGER_L2: (&str, [u8; 20]) = (
@@ -509,12 +534,13 @@ pub mod global_exit_root {
     pub const TIMESTAMP_STORAGE_POS: (&str, u64) = ("TIMESTAMP_STORAGE_POS", 2);
     pub const BLOCK_INFO_ROOT_STORAGE_POS: (&str, u64) = ("BLOCK_INFO_ROOT_STORAGE_POS", 3);
 
+    pub const GLOBAL_EXIT_ROOT_CONTRACT_CODE_LEN_U256: U256 = U256([0, 0, 0, 2112]);
     /// Taken from <https://zkevm.polygonscan.com/address/0xa40D5f56745a118D0906a34E69aeC8C0Db1cB8fA#code>.
     pub const GLOBAL_EXIT_ROOT_CONTRACT_CODE: [u8; 2112] = hex!("60806040526004361061004e5760003560e01c80633659cfe6146100655780634f1ef286146100855780635c60da1b146100985780638f283970146100c9578063f851a440146100e95761005d565b3661005d5761005b6100fe565b005b61005b6100fe565b34801561007157600080fd5b5061005b6100803660046106ca565b610118565b61005b6100933660046106e5565b61015f565b3480156100a457600080fd5b506100ad6101d0565b6040516001600160a01b03909116815260200160405180910390f35b3480156100d557600080fd5b5061005b6100e43660046106ca565b61020b565b3480156100f557600080fd5b506100ad610235565b610106610292565b610116610111610331565b61033b565b565b61012061035f565b6001600160a01b0316336001600160a01b031614156101575761015481604051806020016040528060008152506000610392565b50565b6101546100fe565b61016761035f565b6001600160a01b0316336001600160a01b031614156101c8576101c38383838080601f01602080910402602001604051908101604052809392919081815260200183838082843760009201919091525060019250610392915050565b505050565b6101c36100fe565b60006101da61035f565b6001600160a01b0316336001600160a01b03161415610200576101fb610331565b905090565b6102086100fe565b90565b61021361035f565b6001600160a01b0316336001600160a01b0316141561015757610154816103f1565b600061023f61035f565b6001600160a01b0316336001600160a01b03161415610200576101fb61035f565b606061028583836040518060600160405280602781526020016107e460279139610445565b9392505050565b3b151590565b61029a61035f565b6001600160a01b0316336001600160a01b031614156101165760405162461bcd60e51b815260206004820152604260248201527f5472616e73706172656e745570677261646561626c6550726f78793a2061646d60448201527f696e2063616e6e6f742066616c6c6261636b20746f2070726f78792074617267606482015261195d60f21b608482015260a4015b60405180910390fd5b60006101fb610519565b3660008037600080366000845af43d6000803e80801561035a573d6000f35b3d6000fd5b60007fb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d61035b546001600160a01b0316919050565b61039b83610541565b6040516001600160a01b038416907fbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b90600090a26000825111806103dc5750805b156101c3576103eb8383610260565b50505050565b7f7e644d79422f17c01e4894b5f4f588d331ebfa28653d42ae832dc59e38c9798f61041a61035f565b604080516001600160a01b03928316815291841660208301520160405180910390a1610154816105e9565b6060833b6104a45760405162461bcd60e51b815260206004820152602660248201527f416464726573733a2064656c65676174652063616c6c20746f206e6f6e2d636f6044820152651b9d1c9858dd60d21b6064820152608401610328565b600080856001600160a01b0316856040516104bf9190610794565b600060405180830381855af49150503d80600081146104fa576040519150601f19603f3d011682016040523d82523d6000602084013e6104ff565b606091505b509150915061050f828286610675565b9695505050505050565b60007f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc610383565b803b6105a55760405162461bcd60e51b815260206004820152602d60248201527f455243313936373a206e657720696d706c656d656e746174696f6e206973206e60448201526c1bdd08184818dbdb9d1c9858dd609a1b6064820152608401610328565b807f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc5b80546001600160a01b0319166001600160a01b039290921691909117905550565b6001600160a01b03811661064e5760405162461bcd60e51b815260206004820152602660248201527f455243313936373a206e65772061646d696e20697320746865207a65726f206160448201526564647265737360d01b6064820152608401610328565b807fb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d61036105c8565b60608315610684575081610285565b8251156106945782518084602001fd5b8160405162461bcd60e51b815260040161032891906107b0565b80356001600160a01b03811681146106c557600080fd5b919050565b6000602082840312156106dc57600080fd5b610285826106ae565b6000806000604084860312156106fa57600080fd5b610703846106ae565b9250602084013567ffffffffffffffff8082111561072057600080fd5b818601915086601f83011261073457600080fd5b81358181111561074357600080fd5b87602082850101111561075557600080fd5b6020830194508093505050509250925092565b60005b8381101561078357818101518382015260200161076b565b838111156103eb5750506000910152565b600082516107a6818460208701610768565b9190910192915050565b60208152600082518060208401526107cf816040850160208701610768565b601f01601f1916919091016040019291505056fe416464726573733a206c6f772d6c6576656c2064656c65676174652063616c6c206661696c6564a26469706673582212204675187caf3a43285d9a2c1844a981e977bd52a85ff073e7fc649f73847d70a464736f6c63430008090033");
     pub const GLOBAL_EXIT_ROOT_CONTRACT_CODE_HASH: [u8; 32] =
         hex!("6bec2bf64f7e824109f6ed55f77dd7665801d6195e461666ad6a5342a9f6daf5");
 
-    pub const GLOBAL_EXIT_ROOT_ACCOUNT: AccountRlp = AccountRlp {
+    pub const GLOBAL_EXIT_ROOT_ACCOUNT: MptAccount = MptAccount {
         nonce: U256::zero(),
         balance: U256::zero(),
         // Empty storage root
diff --git a/evm_arithmetization/src/cpu/kernel/constants/smt_type.rs b/evm_arithmetization/src/cpu/kernel/constants/smt_type.rs
new file mode 100644
index 000000000..b134598bc
--- /dev/null
+++ b/evm_arithmetization/src/cpu/kernel/constants/smt_type.rs
@@ -0,0 +1,23 @@
+#[derive(Copy, Clone, Debug)]
+pub(crate) enum PartialSmtType {
+    Hash = 0,
+    Internal = 1,
+    Leaf = 2,
+}
+
+impl PartialSmtType {
+    pub(crate) const COUNT: usize = 3;
+
+    pub(crate) fn all() -> [Self; Self::COUNT] {
+        [Self::Hash, Self::Internal, Self::Leaf]
+    }
+
+    /// The variable name that gets passed into kernel assembly code.
+    pub(crate) fn var_name(&self) -> &'static str {
+        match self {
+            Self::Hash => "SMT_NODE_HASH",
+            Self::Internal => "SMT_NODE_INTERNAL",
+            Self::Leaf => "SMT_NODE_LEAF",
+        }
+    }
+}
diff --git a/evm_arithmetization/src/cpu/kernel/interpreter.rs b/evm_arithmetization/src/cpu/kernel/interpreter.rs
index d9745504e..263dd4529 100644
--- a/evm_arithmetization/src/cpu/kernel/interpreter.rs
+++ b/evm_arithmetization/src/cpu/kernel/interpreter.rs
@@ -13,14 +13,16 @@ use log::Level;
 use mpt_trie::partial_trie::PartialTrie;
 use plonky2::hash::hash_types::RichField;
 use serde::{Deserialize, Serialize};
+#[cfg(feature = "cdk_erigon")]
+use smt_trie::smt::hash_serialize_u256;
 
 use crate::byte_packing::byte_packing_stark::BytePackingOp;
 use crate::cpu::columns::CpuColumnsView;
 use crate::cpu::kernel::aggregator::KERNEL;
 use crate::cpu::kernel::constants::global_metadata::GlobalMetadata;
 use crate::generation::debug_inputs;
-use crate::generation::linked_list::LinkedListsPtrs;
-use crate::generation::mpt::{load_linked_lists_and_txn_and_receipt_mpts, TrieRootPtrs};
+use crate::generation::linked_list::{AccessLinkedListsPtrs, StateLinkedListsPtrs};
+use crate::generation::mpt::TrieRootPtrs;
 use crate::generation::rlp::all_rlp_prover_inputs_reversed;
 use crate::generation::state::{
     all_ger_prover_inputs, all_withdrawals_prover_inputs_reversed, GenerationState,
@@ -117,8 +119,8 @@ pub(crate) struct ExtraSegmentData {
     pub(crate) ger_prover_inputs: Vec<U256>,
     pub(crate) trie_root_ptrs: TrieRootPtrs,
     pub(crate) jumpdest_table: Option<HashMap<usize, Vec<usize>>>,
-    pub(crate) access_lists_ptrs: LinkedListsPtrs,
-    pub(crate) state_ptrs: LinkedListsPtrs,
+    pub(crate) access_lists_ptrs: AccessLinkedListsPtrs,
+    pub(crate) state_ptrs: StateLinkedListsPtrs,
     pub(crate) next_txn_index: usize,
 }
 
@@ -236,33 +238,14 @@ impl<F: RichField> Interpreter<F> {
         // Set state's inputs. We trim unnecessary components.
         self.generation_state.inputs = inputs.trim();
 
-        // Initialize the MPT's pointers.
-        let (trie_root_ptrs, state_leaves, storage_leaves, trie_data) =
-            load_linked_lists_and_txn_and_receipt_mpts(
-                &mut self.generation_state.state_ptrs.accounts,
-                &mut self.generation_state.state_ptrs.storage,
-                &inputs.tries,
-            )
-            .expect("Invalid MPT data for preinitialization");
+        log::debug!("interpreter");
+        let trie_root_ptrs = self
+            .generation_state
+            .preinitialize_trie_data_and_get_trie_ptrs(tries);
 
         let trie_roots_after = &inputs.trie_roots_after;
         self.generation_state.trie_root_ptrs = trie_root_ptrs;
 
-        // Initialize the `TrieData` segment.
-        let preinit_trie_data_segment = MemorySegmentState { content: trie_data };
-        let preinit_accounts_ll_segment = MemorySegmentState {
-            content: state_leaves,
-        };
-        let preinit_storage_ll_segment = MemorySegmentState {
-            content: storage_leaves,
-        };
-        self.insert_preinitialized_segment(Segment::TrieData, preinit_trie_data_segment);
-        self.insert_preinitialized_segment(
-            Segment::AccountsLinkedList,
-            preinit_accounts_ll_segment,
-        );
-        self.insert_preinitialized_segment(Segment::StorageLinkedList, preinit_storage_ll_segment);
-
         // Update the RLP and withdrawal prover inputs.
         let rlp_prover_inputs = all_rlp_prover_inputs_reversed(&inputs.signed_txns);
         let withdrawal_prover_inputs = all_withdrawals_prover_inputs_reversed(&inputs.withdrawals);
@@ -317,7 +300,25 @@ impl<F: RichField> Interpreter<F> {
             ),
             (
                 GlobalMetadata::StateTrieRootDigestBefore,
-                h2u(tries.state_trie.hash()),
+                // TODO: We should reuse the serialized trie in memory.
+                #[cfg(not(feature = "cdk_erigon"))]
+                h2u(tries
+                    .state_trie
+                    .state
+                    .clone()
+                    .expect_left("eth_mainnet expects MPTs.")
+                    .state_trie()
+                    .hash()),
+                #[cfg(feature = "cdk_erigon")]
+                hash_serialize_u256(
+                    &tries
+                        .state_trie
+                        .state
+                        .clone()
+                        .expect_right("cdk_erigon expects SMTs.")
+                        .as_smt()
+                        .to_vec(),
+                ),
             ),
             (
                 GlobalMetadata::TransactionTrieRootDigestBefore,
@@ -502,14 +503,6 @@ impl<F: RichField> Interpreter<F> {
             .set(MemoryAddress::new(0, Segment::RlpRaw, 0), 0x80.into())
     }
 
-    /// Inserts a preinitialized segment, given as a [Segment],
-    /// into the `preinitialized_segments` memory field.
-    fn insert_preinitialized_segment(&mut self, segment: Segment, values: MemorySegmentState) {
-        self.generation_state
-            .memory
-            .insert_preinitialized_segment(segment, values);
-    }
-
     pub(crate) fn is_preinitialized_segment(&self, segment: usize) -> bool {
         self.generation_state
             .memory
diff --git a/evm_arithmetization/src/cpu/kernel/mod.rs b/evm_arithmetization/src/cpu/kernel/mod.rs
index 8a2f4317b..50e377ae8 100644
--- a/evm_arithmetization/src/cpu/kernel/mod.rs
+++ b/evm_arithmetization/src/cpu/kernel/mod.rs
@@ -18,7 +18,7 @@ pub use constants::cancun_constants;
 pub use constants::global_exit_root;
 
 #[cfg(test)]
-mod tests;
+pub(crate) mod tests;
 
 use assembler::assemble;
 use parser::parse;
diff --git a/evm_arithmetization/src/cpu/kernel/opcodes.rs b/evm_arithmetization/src/cpu/kernel/opcodes.rs
index 6491003f1..fde72e247 100644
--- a/evm_arithmetization/src/cpu/kernel/opcodes.rs
+++ b/evm_arithmetization/src/cpu/kernel/opcodes.rs
@@ -39,6 +39,8 @@ pub fn get_opcode(mnemonic: &str) -> u8 {
         "SAR" => 0x1d,
         "KECCAK256" => 0x20,
         "KECCAK_GENERAL" => 0x21,
+        "POSEIDON" => 0x22,
+        "POSEIDON_GENERAL" => 0x23,
         "ADDRESS" => 0x30,
         "BALANCE" => 0x31,
         "ORIGIN" => 0x32,
diff --git a/evm_arithmetization/src/cpu/kernel/tests/account_code.rs b/evm_arithmetization/src/cpu/kernel/tests/account_code.rs
index 8af4ed4a8..b698ac0df 100644
--- a/evm_arithmetization/src/cpu/kernel/tests/account_code.rs
+++ b/evm_arithmetization/src/cpu/kernel/tests/account_code.rs
@@ -1,6 +1,8 @@
 use std::collections::HashMap;
 
 use anyhow::Result;
+use either::Either;
+use env_logger::{try_init_from_env, Env, DEFAULT_FILTER_ENV};
 use ethereum_types::{Address, BigEndianHash, H256, U256};
 use hex_literal::hex;
 use keccak_hash::keccak;
@@ -9,6 +11,9 @@ use mpt_trie::partial_trie::{HashedPartialTrie, Node, PartialTrie};
 use plonky2::field::goldilocks_field::GoldilocksField as F;
 use plonky2::hash::hash_types::RichField;
 use rand::{thread_rng, Rng};
+use smt_trie::code::hash_bytecode_h256;
+#[cfg(feature = "cdk_erigon")]
+use smt_trie::utils::key2u;
 
 use crate::cpu::kernel::aggregator::KERNEL;
 use crate::cpu::kernel::constants::context_metadata::ContextMetadata::{self, GasLimit};
@@ -16,48 +21,104 @@ use crate::cpu::kernel::constants::global_metadata::GlobalMetadata;
 use crate::cpu::kernel::constants::INITIAL_RLP_ADDR;
 use crate::cpu::kernel::interpreter::Interpreter;
 use crate::cpu::kernel::tests::mpt::nibbles_64;
+#[cfg(not(feature = "cdk_erigon"))]
+use crate::generation::mpt::load_linked_lists;
 use crate::generation::mpt::{
-    load_linked_lists_and_txn_and_receipt_mpts, load_state_mpt, AccountRlp,
+    load_receipts_mpt, load_state_mpt, load_transactions_mpt, Account, EitherAccount, MptAccount,
+    SmtAccount, TrieRootPtrs,
 };
 use crate::generation::TrieInputs;
 use crate::memory::segments::Segment;
 use crate::util::h2u;
 use crate::witness::memory::MemoryAddress;
 use crate::witness::operation::CONTEXT_SCALING_FACTOR;
+use crate::world::StateWorld;
 
 pub(crate) fn initialize_mpts<F: RichField>(
     interpreter: &mut Interpreter<F>,
     trie_inputs: &TrieInputs,
 ) {
+    #[cfg(feature = "cdk_erigon")]
+    {
+        interpreter
+            .generation_state
+            .preinitialize_linked_lists(trie_inputs);
+    }
+
     // Load all MPTs.
-    let (mut trie_root_ptrs, state_leaves, storage_leaves, trie_data) =
-        load_linked_lists_and_txn_and_receipt_mpts(
-            &mut interpreter.generation_state.state_ptrs.accounts,
-            &mut interpreter.generation_state.state_ptrs.storage,
+    #[cfg(not(feature = "cdk_erigon"))]
+    {
+        let (state_leaves, storage_leaves, mut trie_data) = load_linked_lists(
+            &mut interpreter
+                .generation_state
+                .state_pointers
+                .accounts_pointers,
+            &mut interpreter.generation_state.state_pointers.storage_pointers,
             trie_inputs,
         )
         .expect("Invalid MPT data for preinitialization");
 
-    interpreter.generation_state.memory.contexts[0].segments
-        [Segment::AccountsLinkedList.unscale()]
-    .content = state_leaves;
-    interpreter.generation_state.memory.contexts[0].segments
-        [Segment::StorageLinkedList.unscale()]
-    .content = storage_leaves;
-    interpreter.generation_state.memory.contexts[0].segments[Segment::TrieData.unscale()].content =
-        trie_data.clone();
-    interpreter.generation_state.trie_root_ptrs = trie_root_ptrs.clone();
-
-    if trie_root_ptrs.state_root_ptr.is_none() {
-        trie_root_ptrs.state_root_ptr = Some(
-            load_state_mpt(
-                &trie_inputs.trim(),
-                &mut interpreter.generation_state.memory.contexts[0].segments
-                    [Segment::TrieData.unscale()]
-                .content,
-            )
-            .expect("Invalid MPT data for preinitialization"),
-        );
+        let txn_root_ptr =
+            load_transactions_mpt(&trie_inputs.transactions_trie, &mut trie_data).unwrap();
+        let receipt_root_ptr =
+            load_receipts_mpt(&trie_inputs.receipts_trie, &mut trie_data).unwrap();
+
+        let mut trie_root_ptrs = TrieRootPtrs {
+            state_root_ptr: None,
+            txn_root_ptr,
+            receipt_root_ptr,
+        };
+
+        log::debug!("trie data len after receipts {:?}", trie_data.len());
+
+        interpreter.generation_state.memory.contexts[0].segments
+            [Segment::AccountsLinkedList.unscale()]
+        .content = state_leaves;
+        interpreter.generation_state.memory.contexts[0].segments
+            [Segment::StorageLinkedList.unscale()]
+        .content = storage_leaves;
+        interpreter.generation_state.memory.contexts[0].segments[Segment::TrieData.unscale()]
+            .content = trie_data.clone();
+        interpreter.generation_state.trie_root_ptrs = trie_root_ptrs.clone();
+
+        if trie_root_ptrs.state_root_ptr.is_none() {
+            trie_root_ptrs.state_root_ptr = Some(
+                load_state_mpt(
+                    &trie_inputs.trim(),
+                    &mut interpreter.generation_state.memory.contexts[0].segments
+                        [Segment::TrieData.unscale()]
+                    .content,
+                )
+                .expect("Invalid MPT data for preinitialization"),
+            );
+        }
+
+        let state_addr =
+            MemoryAddress::new_bundle((GlobalMetadata::StateTrieRoot as usize).into()).unwrap();
+        let txn_addr =
+            MemoryAddress::new_bundle((GlobalMetadata::TransactionTrieRoot as usize).into())
+                .unwrap();
+        let receipts_addr =
+            MemoryAddress::new_bundle((GlobalMetadata::ReceiptTrieRoot as usize).into()).unwrap();
+
+        let mut to_set = vec![];
+        if let Some(state_root_ptr) = trie_root_ptrs.state_root_ptr {
+            to_set.push((state_addr, state_root_ptr.into()));
+        }
+        to_set.extend([
+            (txn_addr, trie_root_ptrs.txn_root_ptr.into()),
+            (receipts_addr, trie_root_ptrs.receipt_root_ptr.into()),
+        ]);
+
+        interpreter.set_memory_multi_addresses(&to_set);
+
+        for (i, data) in trie_data.iter().enumerate() {
+            let trie_addr = MemoryAddress::new(0, Segment::TrieData, i);
+            interpreter
+                .generation_state
+                .memory
+                .set(trie_addr, data.unwrap_or_default());
+        }
     }
 
     let accounts_len = Segment::AccountsLinkedList as usize
@@ -106,32 +167,6 @@ pub(crate) fn initialize_mpts<F: RichField>(
         (initial_accounts_len_addr, accounts_len.into()),
         (initial_storage_len_addr, storage_len.into()),
     ]);
-
-    let state_addr =
-        MemoryAddress::new_bundle((GlobalMetadata::StateTrieRoot as usize).into()).unwrap();
-    let txn_addr =
-        MemoryAddress::new_bundle((GlobalMetadata::TransactionTrieRoot as usize).into()).unwrap();
-    let receipts_addr =
-        MemoryAddress::new_bundle((GlobalMetadata::ReceiptTrieRoot as usize).into()).unwrap();
-
-    let mut to_set = vec![];
-    if let Some(state_root_ptr) = trie_root_ptrs.state_root_ptr {
-        to_set.push((state_addr, state_root_ptr.into()));
-    }
-    to_set.extend([
-        (txn_addr, trie_root_ptrs.txn_root_ptr.into()),
-        (receipts_addr, trie_root_ptrs.receipt_root_ptr.into()),
-    ]);
-
-    interpreter.set_memory_multi_addresses(&to_set);
-
-    for (i, data) in trie_data.iter().enumerate() {
-        let trie_addr = MemoryAddress::new(0, Segment::TrieData, i);
-        interpreter
-            .generation_state
-            .memory
-            .set(trie_addr, data.unwrap_or_default());
-    }
 }
 
 // Stolen from `tests/mpt/insert.rs`
@@ -139,16 +174,20 @@ pub(crate) fn initialize_mpts<F: RichField>(
 pub(crate) fn prepare_interpreter<F: RichField>(
     interpreter: &mut Interpreter<F>,
     address: Address,
-    account: &AccountRlp,
+    account: &EitherAccount,
 ) -> Result<()> {
-    let mpt_insert_state_trie = KERNEL.global_labels["mpt_insert_state_trie"];
+    let insert_state_trie = if cfg!(feature = "cdk_erigon") {
+        KERNEL.global_labels["insert_key"]
+    } else {
+        KERNEL.global_labels["insert_account_with_overwrite"]
+    };
     let check_state_trie = KERNEL.global_labels["check_final_state_trie"];
-    let mut state_trie: HashedPartialTrie = HashedPartialTrie::from(Node::Empty);
+    let mut state_trie = StateWorld::default();
+    let expected_state_trie_hash = set_account(&mut state_trie, address, &account);
     let trie_inputs = TrieInputs {
-        state_trie: HashedPartialTrie::from(Node::Empty),
+        state_trie: StateWorld::default(),
         transactions_trie: HashedPartialTrie::from(Node::Empty),
         receipts_trie: HashedPartialTrie::from(Node::Empty),
-        storage_tries: vec![],
     };
 
     initialize_mpts(interpreter, &trie_inputs);
@@ -158,34 +197,80 @@ pub(crate) fn prepare_interpreter<F: RichField>(
         keccak(address.to_fixed_bytes()).as_bytes(),
     ));
     // Next, execute mpt_insert_state_trie.
-    interpreter.generation_state.registers.program_counter = mpt_insert_state_trie;
+    interpreter.generation_state.registers.program_counter = insert_state_trie;
     let trie_data = interpreter.get_trie_data_mut();
     if trie_data.is_empty() {
         // In the assembly we skip over 0, knowing trie_data[0] = 0 by default.
         // Since we don't explicitly set it to 0, we need to do so here.
         trie_data.push(Some(0.into()));
     }
-    let value_ptr = trie_data.len();
-    trie_data.push(Some(account.nonce));
-    trie_data.push(Some(account.balance));
-    // In memory, storage_root gets interpreted as a pointer to a storage trie,
-    // so we have to ensure the pointer is valid. It's easiest to set it to 0,
-    // which works as an empty node, since trie_data[0] = 0 = MPT_TYPE_EMPTY.
-    trie_data.push(Some(H256::zero().into_uint()));
-    trie_data.push(Some(account.code_hash.into_uint()));
-    let trie_data_len = trie_data.len().into();
-    interpreter.set_global_metadata_field(GlobalMetadata::TrieDataSize, trie_data_len);
-    interpreter
-        .push(0xDEADBEEFu32.into())
-        .expect("The stack should not overflow");
-    interpreter
-        .push(value_ptr.into())
-        .expect("The stack should not overflow"); // value_ptr
-    interpreter
-        .push(k.try_into().unwrap())
-        .expect("The stack should not overflow"); // key
 
-    interpreter.run()?;
+    #[cfg(feature = "cdk_erigon")]
+    {
+        let right_state_trie = state_trie
+            .state
+            .expect_right("cdk_erigon expects SMTs.")
+            .as_smt();
+        let mut kv_sorted_by_k: Vec<(U256, U256)> = right_state_trie
+            .kv_store
+            .iter()
+            .map(|(&key, &val)| (key2u(key), val))
+            .collect();
+        kv_sorted_by_k.sort_by(|(k1, _), (k2, _)| k1.cmp(k2));
+
+        trie_data.extend(
+            right_state_trie
+                .to_vec_skip_empty_node_and_add_offset(2)
+                .iter()
+                .map(|v| Some(*v)),
+        );
+
+        let trie_data_len = trie_data.len().into();
+        interpreter.set_global_metadata_field(GlobalMetadata::TrieDataSize, trie_data_len);
+        let accounts_list_next_pointer = Segment::AccountsLinkedList as usize + 4;
+        interpreter.set_global_metadata_field(
+            GlobalMetadata::AccountsLinkedListNextAvailable,
+            accounts_list_next_pointer.into(),
+        );
+
+        for (key, v) in kv_sorted_by_k {
+            interpreter.generation_state.registers.program_counter = insert_state_trie;
+
+            interpreter
+                .push(0xDEADBEEFu32.into())
+                .expect("The stack should not overflow");
+            interpreter.push(v).expect("The stack should not overflow"); // value
+            interpreter
+                .push(key)
+                .expect("The stack should not overflow"); // key
+            interpreter.run()?;
+        }
+    }
+    #[cfg(not(feature = "cdk_erigon"))]
+    {
+        let value_ptr = trie_data.len();
+        trie_data.push(Some(account.get_nonce()));
+        trie_data.push(Some(account.get_balance()));
+        // In memory, storage_root gets interpreted as a pointer to a storage trie,
+        // so we have to ensure the pointer is valid. It's easiest to set it to 0,
+        // which works as an empty node, since trie_data[0] = 0 = MPT_TYPE_EMPTY.
+        trie_data.push(Some(H256::zero().into_uint()));
+        trie_data.push(Some(account.get_code_hash_u256()));
+        let trie_data_len = trie_data.len().into();
+        interpreter.set_global_metadata_field(GlobalMetadata::TrieDataSize, trie_data_len);
+
+        interpreter
+            .push(0xDEADBEEFu32.into())
+            .expect("The stack should not overflow");
+        interpreter
+            .push(value_ptr.into())
+            // .push(0.into())
+            .expect("The stack should not overflow"); // value_ptr
+        interpreter
+            .push(k.try_into().unwrap())
+            .expect("The stack should not overflow"); // key
+        interpreter.run()?;
+    }
 
     assert_eq!(
         interpreter.stack().len(),
@@ -198,39 +283,25 @@ pub(crate) fn prepare_interpreter<F: RichField>(
     interpreter
         .push(0xDEADBEEFu32.into())
         .expect("The stack should not overflow");
-    interpreter
-        .push((Segment::StorageLinkedList as usize + 5).into())
-        .expect("The stack should not overflow");
-    interpreter
-        .push(interpreter.get_global_metadata_field(GlobalMetadata::StateTrieRoot))
-        .unwrap();
-    interpreter
-        .push((Segment::AccountsLinkedList as usize + 4).into())
-        .expect("The stack should not overflow");
 
     // Now, set the payload.
     interpreter.generation_state.registers.program_counter =
-        KERNEL.global_labels["insert_all_initial_accounts"];
+        KERNEL.global_labels["store_initial_state"];
 
     interpreter.run()?;
 
-    assert_eq!(interpreter.stack_len(), 1);
+    assert_eq!(interpreter.stack_len(), 0);
 
-    let state_root = interpreter.pop().expect("The stack should not be empty");
-    interpreter.set_global_metadata_field(GlobalMetadata::StateTrieRoot, state_root);
-
-    // Now, execute `mpt_hash_state_trie`.
-    state_trie.insert(k, rlp::encode(account).to_vec())?;
-    let expected_state_trie_hash = state_trie.hash();
+    // Now, hash the initial state trie.
     interpreter.set_global_metadata_field(
-        GlobalMetadata::StateTrieRootDigestAfter,
-        h2u(expected_state_trie_hash),
+        GlobalMetadata::StateTrieRootDigestBefore,
+        expected_state_trie_hash,
     );
 
     interpreter.generation_state.registers.program_counter = check_state_trie;
     interpreter
         .halt_offsets
-        .push(KERNEL.global_labels["check_txn_trie"]);
+        .push(KERNEL.global_labels["check_final_state_trie"]);
     interpreter
         .push(0xDEADBEEFu32.into())
         .expect("The stack should not overflow");
@@ -250,12 +321,21 @@ pub(crate) fn prepare_interpreter<F: RichField>(
 }
 
 // Test account with a given code hash.
-fn test_account(code: &[u8]) -> AccountRlp {
-    AccountRlp {
-        nonce: U256::from(1111),
-        balance: U256::from(2222),
-        storage_root: HashedPartialTrie::from(Node::Empty).hash(),
-        code_hash: keccak(code),
+fn test_account(code: &[u8]) -> EitherAccount {
+    if cfg!(feature = "eth_mainnet") {
+        EitherAccount(Either::Left(MptAccount {
+            nonce: U256::from(1111),
+            balance: U256::from(2222),
+            storage_root: HashedPartialTrie::from(Node::Empty).hash(),
+            code_hash: keccak(code),
+        }))
+    } else {
+        EitherAccount(Either::Right(SmtAccount {
+            nonce: U256::from(1111),
+            balance: U256::from(2222),
+            code_hash: hash_bytecode_h256(&code).into_uint(),
+            code_length: code.len().into(),
+        }))
     }
 }
 
@@ -288,8 +368,12 @@ fn test_extcodesize() -> Result<()> {
     interpreter
         .push(U256::from_big_endian(address.as_bytes()))
         .expect("The stack should not overflow");
-    interpreter.generation_state.inputs.contract_code =
-        HashMap::from([(keccak(&code), code.clone())]);
+    interpreter.generation_state.inputs.contract_code = if cfg!(feature = "eth_mainnet") {
+        HashMap::from([(keccak(&code), code.clone())])
+    } else {
+        HashMap::from([(hash_bytecode_h256(&code), code.clone())])
+    };
+
     interpreter.run()?;
 
     assert_eq!(
@@ -362,8 +446,12 @@ fn test_extcodecopy() -> Result<()> {
     interpreter
         .push((0xDEADBEEFu64 + (1 << 32)).into())
         .expect("The stack should not overflow"); // kexit_info
-    interpreter.generation_state.inputs.contract_code =
-        HashMap::from([(keccak(&code), code.clone())]);
+    interpreter.generation_state.inputs.contract_code = if cfg!(feature = "eth_mainnet") {
+        HashMap::from([(keccak(&code), code.clone())])
+    } else {
+        HashMap::from([(hash_bytecode_h256(&code), code.clone())])
+    };
+
     interpreter.run()?;
 
     assert!(interpreter.stack().is_empty());
@@ -460,7 +548,11 @@ fn prepare_interpreter_all_accounts<F: RichField>(
 
 /// Tests an SSTORE within a code similar to the contract code in add11_yml.
 #[test]
+#[cfg(not(feature = "cdk_erigon"))]
 fn sstore() -> Result<()> {
+    use crate::testing_utils::get_state_world;
+
+    init_logger();
     // We take the same `to` account as in add11_yml.
     let addr = hex!("095e7baea6a6c7c4c2dfeb977efac326af552d87");
 
@@ -471,21 +563,23 @@ fn sstore() -> Result<()> {
     let code = [0x60, 0x01, 0x60, 0x01, 0x01, 0x60, 0x00, 0x55, 0x00];
     let code_hash = keccak(code);
 
-    let account_before = AccountRlp {
+    let account_before = EitherAccount(Either::Left(MptAccount {
         balance: 0x0de0b6b3a7640000u64.into(),
         code_hash,
-        ..AccountRlp::default()
-    };
+        ..MptAccount::default()
+    }));
 
     let mut state_trie_before = HashedPartialTrie::from(Node::Empty);
 
-    state_trie_before.insert(addr_nibbles, rlp::encode(&account_before).to_vec())?;
-
+    state_trie_before.insert(addr_nibbles, account_before.rlp_encode().to_vec())?;
+    let state_trie = get_state_world(
+        state_trie_before,
+        vec![(addr_hashed, HashedPartialTrie::from(Node::Empty))],
+    );
     let trie_inputs = TrieInputs {
-        state_trie: state_trie_before.clone(),
+        state_trie,
         transactions_trie: Node::Empty.into(),
         receipts_trie: Node::Empty.into(),
-        storage_tries: vec![(addr_hashed, Node::Empty.into())],
     };
 
     let initial_stack = vec![];
@@ -511,7 +605,7 @@ fn sstore() -> Result<()> {
 
     // The code should have added an element to the storage of `to_account`. We run
     // `mpt_hash_state_trie` to check that.
-    let account_after = AccountRlp {
+    let account_after = EitherAccount(Either::Left(MptAccount {
         balance: 0x0de0b6b3a7640000u64.into(),
         code_hash,
         storage_root: HashedPartialTrie::from(Node::Leaf {
@@ -519,11 +613,11 @@ fn sstore() -> Result<()> {
             value: vec![2],
         })
         .hash(),
-        ..AccountRlp::default()
-    };
+        ..MptAccount::default()
+    }));
 
     let mut expected_state_trie_after = HashedPartialTrie::from(Node::Empty);
-    expected_state_trie_after.insert(addr_nibbles, rlp::encode(&account_after).to_vec())?;
+    expected_state_trie_after.insert(addr_nibbles, account_after.rlp_encode().to_vec())?;
 
     let expected_state_trie_hash = expected_state_trie_after.hash();
 
@@ -543,6 +637,7 @@ fn sstore() -> Result<()> {
     interpreter
         .push(1.into()) // Initial length of the trie data segment, unused.
         .expect("The stack should not overflow");
+    log::debug!("donde estas satanas");
     interpreter.run()?;
 
     Ok(())
@@ -550,7 +645,15 @@ fn sstore() -> Result<()> {
 
 /// Tests an SLOAD within a code similar to the contract code in add11_yml.
 #[test]
+#[cfg(not(feature = "cdk_erigon"))]
 fn sload() -> Result<()> {
+    use std::collections::BTreeMap;
+
+    use crate::{
+        tries::{StateMpt, StorageTrie},
+        world::Type1World,
+    };
+
     let addr = hex!("095e7baea6a6c7c4c2dfeb977efac326af552d87");
 
     let addr_hashed = keccak(addr);
@@ -565,21 +668,34 @@ fn sload() -> Result<()> {
     ];
     let code_hash = keccak(code);
 
-    let account_before = AccountRlp {
+    let account_before = EitherAccount(Either::Left(MptAccount {
         balance: 0x0de0b6b3a7640000u64.into(),
         code_hash,
-        ..AccountRlp::default()
-    };
+        ..MptAccount::default()
+    }));
 
     let mut state_trie_before = HashedPartialTrie::from(Node::Empty);
 
-    state_trie_before.insert(addr_nibbles, rlp::encode(&account_before).to_vec())?;
-
+    state_trie_before.insert(addr_nibbles, account_before.rlp_encode().to_vec())?;
+
+    let mut type1world = Type1World::new(
+        StateMpt::new_with_inner(state_trie_before.clone()),
+        BTreeMap::default(),
+    )
+    .unwrap();
+    let storage_tries = vec![(addr_hashed, Node::Empty.into())];
+    let mut init_storage = BTreeMap::default();
+    for (storage, v) in storage_tries {
+        init_storage.insert(storage, StorageTrie::new_with_trie(v));
+    }
+    type1world.set_storage(init_storage);
+    let state_trie = StateWorld {
+        state: Either::Left(type1world),
+    };
     let trie_inputs = TrieInputs {
-        state_trie: state_trie_before.clone(),
+        state_trie,
         transactions_trie: Node::Empty.into(),
         receipts_trie: Node::Empty.into(),
-        storage_tries: vec![(addr_hashed, Node::Empty.into())],
     };
 
     let initial_stack = vec![];
@@ -646,3 +762,54 @@ fn sload() -> Result<()> {
     assert_eq!(hash, expected_state_trie_hash);
     Ok(())
 }
+
+fn init_logger() {
+    let _ = try_init_from_env(Env::default().filter_or(DEFAULT_FILTER_ENV, "info"));
+}
+
+fn set_account(world: &mut StateWorld, addr: Address, account: &EitherAccount) -> U256 {
+    use plonky2::field::types::PrimeField64;
+    use smt_trie::{
+        keys::{key_balance, key_code_length},
+        utils::hashout2u,
+    };
+
+    use crate::world::World;
+
+    match &mut world.state {
+        Either::Left(type1world) => {
+            let state_trie = type1world.state_trie_mut();
+            let k = nibbles_64(U256::from_big_endian(
+                keccak(addr.to_fixed_bytes()).as_bytes(),
+            ));
+            let _ = state_trie.insert(k, account.as_mpt_account().rlp_encode().to_vec());
+            h2u(state_trie.hash())
+        }
+        Either::Right(type2world) => {
+            let acct = account.as_smt_account();
+            let key = key_balance(addr);
+            log::debug!(
+                "setting {:?} balance to {:?}, the key is {:?}",
+                addr,
+                account.get_balance(),
+                U256(std::array::from_fn(|i| key.0[i].to_canonical_u64()))
+            );
+            let _ = type2world.update_balance(addr, |b| *b = account.get_balance());
+
+            let _ = type2world.update_balance(addr, |b| *b = account.get_balance());
+            let _ = type2world.update_nonce(addr, |n| *n = account.get_nonce());
+            type2world.set_code_and_hash(
+                addr,
+                Either::Right(acct.code_hash),
+                Some(acct.code_length),
+            );
+            let key = key_code_length(addr);
+            log::debug!(
+                "setting {:?} code length, the key is {:?}",
+                addr,
+                U256(std::array::from_fn(|i| key.0[i].to_canonical_u64()))
+            );
+            hashout2u(type2world.as_smt().root)
+        }
+    }
+}
diff --git a/evm_arithmetization/src/cpu/kernel/tests/add11.rs b/evm_arithmetization/src/cpu/kernel/tests/add11.rs
index 683987244..1b500550a 100644
--- a/evm_arithmetization/src/cpu/kernel/tests/add11.rs
+++ b/evm_arithmetization/src/cpu/kernel/tests/add11.rs
@@ -1,8 +1,9 @@
-#![cfg(not(feature = "cdk_erigon"))]
+// #![cfg(feature = "eth_mainnet")]
 
 use std::collections::HashMap;
 use std::str::FromStr;
 
+use either::Either;
 use ethereum_types::{Address, BigEndianHash, H256};
 use hex_literal::hex;
 use keccak_hash::keccak;
@@ -10,16 +11,14 @@ use mpt_trie::nibbles::Nibbles;
 use mpt_trie::partial_trie::{HashedPartialTrie, Node, PartialTrie};
 use plonky2::field::goldilocks_field::GoldilocksField as F;
 use plonky2::field::types::Field;
+use smt_trie::code::hash_bytecode_h256;
 
 use crate::cpu::kernel::aggregator::KERNEL;
 use crate::cpu::kernel::interpreter::Interpreter;
-use crate::generation::mpt::{AccountRlp, LegacyReceiptRlp};
+use crate::generation::mpt::{Account, EitherAccount, LegacyReceiptRlp, MptAccount, SmtAccount};
 use crate::generation::TrieInputs;
 use crate::proof::{BlockHashes, BlockMetadata, TrieRoots};
-use crate::testing_utils::{
-    beacon_roots_account_nibbles, beacon_roots_contract_from_storage,
-    preinitialized_state_and_storage_tries, update_beacon_roots_account_storage,
-};
+use crate::testing_utils::*;
 use crate::{GenerationInputs, EMPTY_CONSOLIDATED_BLOCKHASH};
 
 #[test]
@@ -37,24 +36,54 @@ fn test_add11_yml() {
     let to_nibbles = Nibbles::from_bytes_be(to_hashed.as_bytes()).unwrap();
 
     let code = [0x60, 0x01, 0x60, 0x01, 0x01, 0x60, 0x00, 0x55, 0x00];
-    let code_hash = keccak(code);
+    let code_hash = if cfg!(feature = "eth_mainnet") {
+        keccak(code)
+    } else {
+        hash_bytecode_h256(&code)
+    };
 
     let mut contract_code = HashMap::new();
-    contract_code.insert(keccak(vec![]), vec![]);
-    contract_code.insert(code_hash, code.to_vec());
+    if cfg!(feature = "eth_mainnet") {
+        contract_code.insert(keccak(vec![]), vec![]);
+        contract_code.insert(code_hash, code.to_vec());
+    }
 
-    let beneficiary_account_before = AccountRlp {
-        nonce: 1.into(),
-        ..AccountRlp::default()
+    let beneficiary_account_before = if cfg!(feature = "eth_mainnet") {
+        EitherAccount(Either::Left(MptAccount {
+            nonce: 1.into(),
+            ..MptAccount::default()
+        }))
+    } else {
+        EitherAccount(Either::Right(SmtAccount {
+            nonce: 1.into(),
+            ..SmtAccount::default()
+        }))
     };
-    let sender_account_before = AccountRlp {
-        balance: 0x0de0b6b3a7640000u64.into(),
-        ..AccountRlp::default()
+    let sender_account_before = if cfg!(feature = "eth_mainnet") {
+        EitherAccount(Either::Left(MptAccount {
+            balance: 0x0de0b6b3a7640000u64.into(),
+            ..MptAccount::default()
+        }))
+    } else {
+        EitherAccount(Either::Right(SmtAccount {
+            balance: 0x0de0b6b3a7640000u64.into(),
+            ..SmtAccount::default()
+        }))
     };
-    let to_account_before = AccountRlp {
-        balance: 0x0de0b6b3a7640000u64.into(),
-        code_hash,
-        ..AccountRlp::default()
+
+    let to_account_before = if cfg!(feature = "eth_mainnet") {
+        EitherAccount(Either::Left(MptAccount {
+            balance: 0x0de0b6b3a7640000u64.into(),
+            code_hash,
+            ..MptAccount::default()
+        }))
+    } else {
+        EitherAccount(Either::Right(SmtAccount {
+            balance: 0x0de0b6b3a7640000u64.into(),
+            code_hash: code_hash.into_uint(),
+            code_length: code.len().into(),
+            ..SmtAccount::default()
+        }))
     };
 
     let (mut state_trie_before, mut storage_tries) =
@@ -63,23 +92,24 @@ fn test_add11_yml() {
     state_trie_before
         .insert(
             beneficiary_nibbles,
-            rlp::encode(&beneficiary_account_before).to_vec(),
+            beneficiary_account_before.rlp_encode().to_vec(),
         )
         .unwrap();
     state_trie_before
-        .insert(sender_nibbles, rlp::encode(&sender_account_before).to_vec())
+        .insert(sender_nibbles, sender_account_before.rlp_encode().to_vec())
         .unwrap();
     state_trie_before
-        .insert(to_nibbles, rlp::encode(&to_account_before).to_vec())
+        .insert(to_nibbles, to_account_before.rlp_encode().to_vec())
         .unwrap();
 
     storage_tries.push((to_hashed, Node::Empty.into()));
 
+    let state_trie = get_state_world(state_trie_before, storage_tries);
     let tries_before = TrieInputs {
-        state_trie: state_trie_before,
+        state_trie,
         transactions_trie: Node::Empty.into(),
         receipts_trie: Node::Empty.into(),
-        storage_tries,
+        // storage_tries,
     };
 
     let txn = hex!("f863800a83061a8094095e7baea6a6c7c4c2dfeb977efac326af552d87830186a0801ba0ffb600e63115a7362e7811894a91d8ba4330e526f22121c994c4692035dfdfd5a06198379fcac8de3dbfac48b165df4bf88e2088f294b61efb9a65fe2281c76e16");
@@ -100,26 +130,51 @@ fn test_add11_yml() {
     };
 
     let expected_state_trie_after = {
-        let beneficiary_account_after = AccountRlp {
-            nonce: 1.into(),
-            ..AccountRlp::default()
+        let beneficiary_account_after = if cfg!(feature = "eth_mainnet") {
+            EitherAccount(Either::Left(MptAccount {
+                nonce: 1.into(),
+                ..MptAccount::default()
+            }))
+        } else {
+            EitherAccount(Either::Right(SmtAccount {
+                nonce: 1.into(),
+                ..SmtAccount::default()
+            }))
         };
-        let sender_account_after = AccountRlp {
-            balance: 0xde0b6b3a75be550u64.into(),
-            nonce: 1.into(),
-            ..AccountRlp::default()
+        let sender_account_after = if cfg!(feature = "eth_mainnet") {
+            EitherAccount(Either::Left(MptAccount {
+                balance: 0xde0b6b3a75be550u64.into(),
+                nonce: 1.into(),
+                ..MptAccount::default()
+            }))
+        } else {
+            EitherAccount(Either::Right(SmtAccount {
+                balance: 0xde0b6b3a75be550u64.into(),
+                nonce: 1.into(),
+                ..SmtAccount::default()
+            }))
         };
-        let to_account_after = AccountRlp {
-            balance: 0xde0b6b3a76586a0u64.into(),
-            code_hash,
-            // Storage map: { 0 => 2 }
-            storage_root: HashedPartialTrie::from(Node::Leaf {
-                nibbles: Nibbles::from_h256_be(keccak([0u8; 32])),
-                value: vec![2],
-            })
-            .hash(),
-            ..AccountRlp::default()
+
+        let to_account_after = if cfg!(feature = "eth_mainnet") {
+            EitherAccount(Either::Left(MptAccount {
+                balance: 0xde0b6b3a76586a0u64.into(),
+                code_hash,
+                // Storage map: { 0 => 2 }
+                storage_root: HashedPartialTrie::from(Node::Leaf {
+                    nibbles: Nibbles::from_h256_be(keccak([0u8; 32])),
+                    value: vec![2],
+                })
+                .hash(),
+                ..MptAccount::default()
+            }))
+        } else {
+            EitherAccount(Either::Right(SmtAccount {
+                balance: 0xde0b6b3a76586a0u64.into(),
+                code_hash: code_hash.into_uint(),
+                ..SmtAccount::default()
+            }))
         };
+
         update_beacon_roots_account_storage(
             &mut beacon_roots_account_storage,
             block_metadata.block_timestamp,
@@ -133,19 +188,19 @@ fn test_add11_yml() {
         expected_state_trie_after
             .insert(
                 beneficiary_nibbles,
-                rlp::encode(&beneficiary_account_after).to_vec(),
+                beneficiary_account_after.rlp_encode().to_vec(),
             )
             .unwrap();
         expected_state_trie_after
-            .insert(sender_nibbles, rlp::encode(&sender_account_after).to_vec())
+            .insert(sender_nibbles, sender_account_after.rlp_encode().to_vec())
             .unwrap();
         expected_state_trie_after
-            .insert(to_nibbles, rlp::encode(&to_account_after).to_vec())
+            .insert(to_nibbles, to_account_after.rlp_encode().to_vec())
             .unwrap();
         expected_state_trie_after
             .insert(
                 beacon_roots_account_nibbles(),
-                rlp::encode(&beacon_roots_account).to_vec(),
+                beacon_roots_account.rlp_encode().to_vec(),
             )
             .unwrap();
         expected_state_trie_after
@@ -221,24 +276,53 @@ fn test_add11_yml_with_exception() {
     let to_nibbles = Nibbles::from_bytes_be(to_hashed.as_bytes()).unwrap();
 
     let code = [0x60, 0x01, 0x60, 0x01, 0x01, 0x8e, 0x00];
-    let code_hash = keccak(code);
+    let code_hash = if cfg!(feature = "eth_mainnet") {
+        keccak(code)
+    } else {
+        hash_bytecode_h256(&code)
+    };
 
     let mut contract_code = HashMap::new();
-    contract_code.insert(keccak(vec![]), vec![]);
-    contract_code.insert(code_hash, code.to_vec());
+    if cfg!(feature = "eth_mainnet") {
+        contract_code.insert(keccak(vec![]), vec![]);
+        contract_code.insert(code_hash, code.to_vec());
+    }
 
-    let beneficiary_account_before = AccountRlp {
-        nonce: 1.into(),
-        ..AccountRlp::default()
+    let beneficiary_account_before = if cfg!(feature = "eth_mainnet") {
+        EitherAccount(Either::Left(MptAccount {
+            nonce: 1.into(),
+            ..MptAccount::default()
+        }))
+    } else {
+        EitherAccount(Either::Right(SmtAccount {
+            nonce: 1.into(),
+            ..SmtAccount::default()
+        }))
     };
-    let sender_account_before = AccountRlp {
-        balance: 0x0de0b6b3a7640000u64.into(),
-        ..AccountRlp::default()
+    let sender_account_before = if cfg!(feature = "eth_mainnet") {
+        EitherAccount(Either::Left(MptAccount {
+            balance: 0x0de0b6b3a7640000u64.into(),
+            ..MptAccount::default()
+        }))
+    } else {
+        EitherAccount(Either::Right(SmtAccount {
+            balance: 0x0de0b6b3a7640000u64.into(),
+            ..SmtAccount::default()
+        }))
     };
-    let to_account_before = AccountRlp {
-        balance: 0x0de0b6b3a7640000u64.into(),
-        code_hash,
-        ..AccountRlp::default()
+    let to_account_before = if cfg!(feature = "eth_mainnet") {
+        EitherAccount(Either::Left(MptAccount {
+            balance: 0x0de0b6b3a7640000u64.into(),
+            code_hash,
+            ..MptAccount::default()
+        }))
+    } else {
+        EitherAccount(Either::Right(SmtAccount {
+            balance: 0x0de0b6b3a7640000u64.into(),
+            code_hash: code_hash.into_uint(),
+            code_length: code.len().into(),
+            ..SmtAccount::default()
+        }))
     };
 
     let (mut state_trie_before, mut storage_tries) =
@@ -247,23 +331,24 @@ fn test_add11_yml_with_exception() {
     state_trie_before
         .insert(
             beneficiary_nibbles,
-            rlp::encode(&beneficiary_account_before).to_vec(),
+            beneficiary_account_before.rlp_encode().to_vec(),
         )
         .unwrap();
     state_trie_before
-        .insert(sender_nibbles, rlp::encode(&sender_account_before).to_vec())
+        .insert(sender_nibbles, sender_account_before.rlp_encode().to_vec())
         .unwrap();
     state_trie_before
-        .insert(to_nibbles, rlp::encode(&to_account_before).to_vec())
+        .insert(to_nibbles, to_account_before.rlp_encode().to_vec())
         .unwrap();
 
     storage_tries.push((to_hashed, Node::Empty.into()));
 
+    let state_trie = get_state_world(state_trie_before, storage_tries);
+
     let tries_before = TrieInputs {
-        state_trie: state_trie_before,
+        state_trie,
         transactions_trie: Node::Empty.into(),
         receipts_trie: Node::Empty.into(),
-        storage_tries,
     };
 
     let txn = hex!("f863800a83061a8094095e7baea6a6c7c4c2dfeb977efac326af552d87830186a0801ba0ffb600e63115a7362e7811894a91d8ba4330e526f22121c994c4692035dfdfd5a06198379fcac8de3dbfac48b165df4bf88e2088f294b61efb9a65fe2281c76e16");
@@ -289,11 +374,20 @@ fn test_add11_yml_with_exception() {
     let expected_state_trie_after = {
         let beneficiary_account_after = beneficiary_account_before;
         // This is the only account that changes: the nonce and the balance are updated.
-        let sender_account_after = AccountRlp {
-            balance: sender_account_before.balance - txn_gas_limit * gas_price,
-            nonce: 1.into(),
-            ..AccountRlp::default()
+        let sender_account_after = if cfg!(feature = "eth_mainnet") {
+            EitherAccount(Either::Left(MptAccount {
+                balance: sender_account_before.get_balance() - txn_gas_limit * gas_price,
+                nonce: 1.into(),
+                ..MptAccount::default()
+            }))
+        } else {
+            EitherAccount(Either::Right(SmtAccount {
+                balance: sender_account_before.get_balance() - txn_gas_limit * gas_price,
+                nonce: 1.into(),
+                ..SmtAccount::default()
+            }))
         };
+
         let to_account_after = to_account_before;
 
         update_beacon_roots_account_storage(
@@ -309,14 +403,14 @@ fn test_add11_yml_with_exception() {
         expected_state_trie_after
             .insert(
                 beneficiary_nibbles,
-                rlp::encode(&beneficiary_account_after).to_vec(),
+                beneficiary_account_after.rlp_encode().to_vec(),
             )
             .unwrap();
         expected_state_trie_after
-            .insert(sender_nibbles, rlp::encode(&sender_account_after).to_vec())
+            .insert(sender_nibbles, sender_account_after.rlp_encode().to_vec())
             .unwrap();
         expected_state_trie_after
-            .insert(to_nibbles, rlp::encode(&to_account_after).to_vec())
+            .insert(to_nibbles, to_account_after.rlp_encode().to_vec())
             .unwrap();
         expected_state_trie_after
             .insert(
diff --git a/evm_arithmetization/src/cpu/kernel/tests/balance.rs b/evm_arithmetization/src/cpu/kernel/tests/balance.rs
index fc4d63347..346a5fe5b 100644
--- a/evm_arithmetization/src/cpu/kernel/tests/balance.rs
+++ b/evm_arithmetization/src/cpu/kernel/tests/balance.rs
@@ -1,4 +1,5 @@
 use anyhow::Result;
+use either::Either;
 use ethereum_types::{Address, BigEndianHash, H256, U256};
 use mpt_trie::partial_trie::{HashedPartialTrie, PartialTrie};
 use plonky2::field::goldilocks_field::GoldilocksField as F;
@@ -7,16 +8,27 @@ use rand::{thread_rng, Rng};
 use crate::cpu::kernel::aggregator::KERNEL;
 use crate::cpu::kernel::interpreter::Interpreter;
 use crate::cpu::kernel::tests::account_code::prepare_interpreter;
-use crate::generation::mpt::AccountRlp;
+use crate::generation::mpt::EitherAccount;
+use crate::generation::mpt::MptAccount;
+use crate::generation::mpt::SmtAccount;
 use crate::Node;
 
 // Test account with a given code hash.
-fn test_account(balance: U256) -> AccountRlp {
-    AccountRlp {
-        nonce: U256::from(1111),
-        balance,
-        storage_root: HashedPartialTrie::from(Node::Empty).hash(),
-        code_hash: H256::from_uint(&U256::from(8888)),
+fn test_account(balance: U256) -> EitherAccount {
+    if cfg!(feature = "eth_mainnet") {
+        EitherAccount(Either::Left(MptAccount {
+            nonce: U256::from(1111),
+            balance,
+            storage_root: HashedPartialTrie::from(Node::Empty).hash(),
+            code_hash: H256::from_uint(&U256::from(8888)),
+        }))
+    } else {
+        EitherAccount(Either::Right(SmtAccount {
+            nonce: U256::from(1111),
+            balance,
+            code_hash: U256::from(8888),
+            code_length: 0.into(),
+        }))
     }
 }
 
diff --git a/evm_arithmetization/src/cpu/kernel/tests/core/jumpdest_analysis.rs b/evm_arithmetization/src/cpu/kernel/tests/core/jumpdest_analysis.rs
index f2d00ede5..1e0e7a9e8 100644
--- a/evm_arithmetization/src/cpu/kernel/tests/core/jumpdest_analysis.rs
+++ b/evm_arithmetization/src/cpu/kernel/tests/core/jumpdest_analysis.rs
@@ -1,4 +1,4 @@
-#![cfg(not(feature = "cdk_erigon"))]
+#![cfg(feature = "eth_mainnet")]
 
 use std::collections::{BTreeSet, HashMap};
 
diff --git a/evm_arithmetization/src/cpu/kernel/tests/init_exc_stop.rs b/evm_arithmetization/src/cpu/kernel/tests/init_exc_stop.rs
index 2dea58b55..3e67b93b8 100644
--- a/evm_arithmetization/src/cpu/kernel/tests/init_exc_stop.rs
+++ b/evm_arithmetization/src/cpu/kernel/tests/init_exc_stop.rs
@@ -1,21 +1,27 @@
-use std::collections::HashMap;
+use std::collections::{BTreeMap, HashMap};
 
-use ethereum_types::U256;
+use either::Either;
+use ethereum_types::{BigEndianHash, U256};
 use keccak_hash::{keccak, H256};
 use mpt_trie::partial_trie::{HashedPartialTrie, PartialTrie};
 use plonky2::field::goldilocks_field::GoldilocksField as F;
 use plonky2::field::types::Field;
+use smt_trie::{code::hash_bytecode_h256, utils::hashout2u};
 
 use crate::cpu::kernel::{aggregator::KERNEL, interpreter::Interpreter};
 use crate::generation::{
     state::State, TrieInputs, NUM_EXTRA_CYCLES_AFTER, NUM_EXTRA_CYCLES_BEFORE,
 };
 use crate::memory::segments::Segment;
+use crate::testing_utils::init_logger;
+#[cfg(feature = "eth_mainnet")]
 use crate::testing_utils::{
-    beacon_roots_account_nibbles, beacon_roots_contract_from_storage, init_logger,
+    beacon_roots_account_nibbles, beacon_roots_contract_from_storage,
     preinitialized_state_and_storage_tries, update_beacon_roots_account_storage,
 };
+use crate::tries::{StateMpt, StorageTrie};
 use crate::witness::{memory::MemoryAddress, state::RegistersState};
+use crate::world::{StateWorld, Type1World};
 use crate::EMPTY_CONSOLIDATED_BLOCKHASH;
 use crate::{
     proof::{BlockHashes, BlockMetadata, TrieRoots},
@@ -44,36 +50,81 @@ fn test_init_exc_stop() {
         ..Default::default()
     };
 
-    let (state_trie_before, storage_tries) = preinitialized_state_and_storage_tries().unwrap();
-    let mut beacon_roots_account_storage = storage_tries[0].1.clone();
+    let state_trie_before = StateWorld::default();
+
     let transactions_trie = HashedPartialTrie::from(Node::Empty);
     let receipts_trie = HashedPartialTrie::from(Node::Empty);
 
-    let expected_state_trie_after = {
-        update_beacon_roots_account_storage(
-            &mut beacon_roots_account_storage,
-            block_metadata.block_timestamp,
-            block_metadata.parent_beacon_block_root,
+    let mut expected_state_trie_after = StateWorld::default();
+    #[cfg(feature = "eth_mainnet")]
+    let (state_trie_before_hashed, storage_tries) =
+        preinitialized_state_and_storage_tries().unwrap();
+    #[cfg(feature = "eth_mainnet")]
+    {
+        let mut type1world = Type1World::new(
+            StateMpt::new_with_inner(state_trie_before_hashed),
+            BTreeMap::default(),
         )
         .unwrap();
-        let beacon_roots_account =
-            beacon_roots_contract_from_storage(&beacon_roots_account_storage);
-
-        let mut expected_state_trie_after = HashedPartialTrie::from(Node::Empty);
-        expected_state_trie_after
-            .insert(
-                beacon_roots_account_nibbles(),
-                rlp::encode(&beacon_roots_account).to_vec(),
+        let mut init_storage = BTreeMap::default();
+        for (storage, v) in &storage_tries {
+            init_storage.insert(*storage, StorageTrie::new_with_trie(v.clone()));
+        }
+        type1world.set_storage(init_storage);
+    }
+
+    #[cfg(feature = "eth_mainnet")]
+    let mut beacon_roots_account_storage = storage_tries[0].1.clone();
+    #[cfg(feature = "eth_mainnet")]
+    {
+        expected_state_trie_after = {
+            update_beacon_roots_account_storage(
+                &mut beacon_roots_account_storage,
+                block_metadata.block_timestamp,
+                block_metadata.parent_beacon_block_root,
             )
             .unwrap();
-        expected_state_trie_after
-    };
+            let beacon_roots_account =
+                beacon_roots_contract_from_storage(&beacon_roots_account_storage);
+
+            let mut expected_state_trie_after = HashedPartialTrie::from(Node::Empty);
+            expected_state_trie_after
+                .insert(
+                    beacon_roots_account_nibbles(),
+                    rlp::encode(&beacon_roots_account).to_vec(),
+                )
+                .unwrap();
+            let mut type1world = Type1World::new(
+                StateMpt::new_with_inner(expected_state_trie_after),
+                BTreeMap::default(),
+            )
+            .unwrap();
+            let mut init_storage = BTreeMap::default();
+            for (storage, v) in storage_tries {
+                init_storage.insert(storage, StorageTrie::new_with_trie(v));
+            }
+            type1world.set_storage(init_storage);
+            StateWorld {
+                state: Either::Left(type1world),
+            }
+        };
+    }
 
     let mut contract_code = HashMap::new();
-    contract_code.insert(keccak(vec![]), vec![]);
 
+    let contract_hash = if cfg!(feature = "eth_mainnet") {
+        keccak(vec![])
+    } else {
+        hash_bytecode_h256(&[])
+    };
+    contract_code.insert(contract_hash, vec![]);
+
+    let state_root = match &expected_state_trie_after.state {
+        Either::Left(type1world) => type1world.state_trie().hash(),
+        Either::Right(type2world) => H256::from_uint(&hashout2u(type2world.as_smt().root)),
+    };
     let trie_roots_after = TrieRoots {
-        state_root: expected_state_trie_after.hash(),
+        state_root,
         transactions_root: transactions_trie.hash(),
         receipts_root: receipts_trie.hash(),
     };
@@ -86,7 +137,6 @@ fn test_init_exc_stop() {
             state_trie: state_trie_before,
             transactions_trie,
             receipts_trie,
-            storage_tries,
         },
         trie_roots_after,
         contract_code,
diff --git a/evm_arithmetization/src/cpu/kernel/tests/mod.rs b/evm_arithmetization/src/cpu/kernel/tests/mod.rs
index 2b983d099..4fce68600 100644
--- a/evm_arithmetization/src/cpu/kernel/tests/mod.rs
+++ b/evm_arithmetization/src/cpu/kernel/tests/mod.rs
@@ -18,7 +18,7 @@ mod init_exc_stop;
 mod kernel_consistency;
 mod log;
 mod mcopy;
-mod mpt;
+pub(crate) mod mpt;
 mod packing;
 mod receipt;
 mod rlp;
diff --git a/evm_arithmetization/src/cpu/kernel/tests/mpt/delete.rs b/evm_arithmetization/src/cpu/kernel/tests/mpt/delete.rs
index 72edba94f..206d4936f 100644
--- a/evm_arithmetization/src/cpu/kernel/tests/mpt/delete.rs
+++ b/evm_arithmetization/src/cpu/kernel/tests/mpt/delete.rs
@@ -11,15 +11,17 @@ use crate::cpu::kernel::constants::INITIAL_RLP_ADDR;
 use crate::cpu::kernel::interpreter::Interpreter;
 use crate::cpu::kernel::tests::account_code::initialize_mpts;
 use crate::cpu::kernel::tests::mpt::{nibbles_64, test_account_1_rlp, test_account_2};
-use crate::generation::mpt::AccountRlp;
+use crate::generation::mpt::MptAccount;
 use crate::generation::TrieInputs;
 use crate::memory::segments::Segment;
+use crate::testing_utils::get_state_world;
 use crate::util::h2u;
 use crate::Node;
 
 #[test]
 fn mpt_delete_empty() -> Result<()> {
-    test_state_trie(Default::default(), nibbles_64(0xABC), test_account_2())
+    let test_account = test_account_2();
+    test_state_trie(Default::default(), nibbles_64(0xABC), test_account)
 }
 
 #[test]
@@ -85,18 +87,18 @@ fn test_after_mpt_delete_extension_branch() -> Result<()> {
 fn test_state_trie(
     state_trie: HashedPartialTrie,
     k: Nibbles,
-    mut account: AccountRlp,
+    mut account: MptAccount,
 ) -> Result<()> {
     assert_eq!(k.count, 64);
 
     // Ignore any storage_root; see documentation note.
     account.storage_root = HashedPartialTrie::from(Node::Empty).hash();
 
+    let state_world = get_state_world(state_trie.clone(), vec![]);
     let trie_inputs = TrieInputs {
-        state_trie: state_trie.clone(),
+        state_trie: state_world,
         transactions_trie: Default::default(),
         receipts_trie: Default::default(),
-        storage_tries: vec![],
     };
     let mpt_insert_state_trie = KERNEL.global_labels["mpt_insert_state_trie"];
     let mpt_delete = KERNEL.global_labels["mpt_delete"];
diff --git a/evm_arithmetization/src/cpu/kernel/tests/mpt/hash.rs b/evm_arithmetization/src/cpu/kernel/tests/mpt/hash.rs
index fdb342805..85652ff8e 100644
--- a/evm_arithmetization/src/cpu/kernel/tests/mpt/hash.rs
+++ b/evm_arithmetization/src/cpu/kernel/tests/mpt/hash.rs
@@ -1,6 +1,6 @@
 use anyhow::Result;
 use ethereum_types::{BigEndianHash, H256};
-use mpt_trie::partial_trie::PartialTrie;
+use mpt_trie::nibbles::Nibbles;
 use plonky2::field::goldilocks_field::GoldilocksField as F;
 
 use crate::cpu::kernel::aggregator::KERNEL;
@@ -9,6 +9,8 @@ use crate::cpu::kernel::interpreter::Interpreter;
 use crate::cpu::kernel::tests::account_code::initialize_mpts;
 use crate::cpu::kernel::tests::mpt::{extension_to_leaf, test_account_1_rlp, test_account_2_rlp};
 use crate::generation::TrieInputs;
+use crate::testing_utils::get_state_world;
+use crate::world::World;
 use crate::Node;
 
 // TODO: Test with short leaf. Might need to be a storage trie.
@@ -19,7 +21,6 @@ fn mpt_hash_empty() -> Result<()> {
         state_trie: Default::default(),
         transactions_trie: Default::default(),
         receipts_trie: Default::default(),
-        storage_tries: vec![],
     };
 
     test_state_trie(trie_inputs)
@@ -28,16 +29,18 @@ fn mpt_hash_empty() -> Result<()> {
 #[test]
 fn mpt_hash_empty_branch() -> Result<()> {
     let children = core::array::from_fn(|_| Node::Empty.into());
-    let state_trie = Node::Branch {
-        children,
-        value: vec![],
-    }
-    .into();
+    let state_trie = get_state_world(
+        Node::Branch {
+            children,
+            value: vec![],
+        }
+        .into(),
+        vec![],
+    );
     let trie_inputs = TrieInputs {
         state_trie,
         transactions_trie: Default::default(),
         receipts_trie: Default::default(),
-        storage_tries: vec![],
     };
     test_state_trie(trie_inputs)
 }
@@ -45,11 +48,12 @@ fn mpt_hash_empty_branch() -> Result<()> {
 #[test]
 fn mpt_hash_hash() -> Result<()> {
     let hash = H256::random();
+
+    let state_trie = get_state_world(Node::Hash(hash).into(), vec![]);
     let trie_inputs = TrieInputs {
-        state_trie: Node::Hash(hash).into(),
+        state_trie,
         transactions_trie: Default::default(),
         receipts_trie: Default::default(),
-        storage_tries: vec![],
     };
 
     test_state_trie(trie_inputs)
@@ -57,28 +61,32 @@ fn mpt_hash_hash() -> Result<()> {
 
 #[test]
 fn mpt_hash_leaf() -> Result<()> {
-    let state_trie = Node::Leaf {
-        nibbles: 0xABC_u64.into(),
-        value: test_account_1_rlp(),
-    }
-    .into();
+    let state_trie = get_state_world(
+        Node::Leaf {
+            nibbles: Nibbles{
+                count: 64,
+                packed: 0xABC_u64.into(),
+            },
+            value: test_account_1_rlp(),
+        }
+        .into(),
+        vec![],
+    );
     let trie_inputs = TrieInputs {
         state_trie,
         transactions_trie: Default::default(),
         receipts_trie: Default::default(),
-        storage_tries: vec![],
     };
     test_state_trie(trie_inputs)
 }
 
 #[test]
 fn mpt_hash_extension_to_leaf() -> Result<()> {
-    let state_trie = extension_to_leaf(test_account_1_rlp());
+    let state_trie = get_state_world(extension_to_leaf(test_account_1_rlp()), vec![]);
     let trie_inputs = TrieInputs {
         state_trie,
         transactions_trie: Default::default(),
         receipts_trie: Default::default(),
-        storage_tries: vec![],
     };
     test_state_trie(trie_inputs)
 }
@@ -86,24 +94,29 @@ fn mpt_hash_extension_to_leaf() -> Result<()> {
 #[test]
 fn mpt_hash_branch_to_leaf() -> Result<()> {
     let leaf = Node::Leaf {
-        nibbles: 0xABC_u64.into(),
+        nibbles: Nibbles {
+            count: 63,
+            packed: 0xABC_u64.into(),
+        },
         value: test_account_2_rlp(),
     }
     .into();
 
     let mut children = core::array::from_fn(|_| Node::Empty.into());
     children[3] = leaf;
-    let state_trie = Node::Branch {
-        children,
-        value: vec![],
-    }
-    .into();
+    let state_trie = get_state_world(
+        Node::Branch {
+            children,
+            value: vec![],
+        }
+        .into(),
+        vec![],
+    );
 
     let trie_inputs = TrieInputs {
         state_trie,
         transactions_trie: Default::default(),
         receipts_trie: Default::default(),
-        storage_tries: vec![],
     };
 
     test_state_trie(trie_inputs)
@@ -138,7 +151,7 @@ fn test_state_trie(trie_inputs: TrieInputs) -> Result<()> {
         interpreter.stack()
     );
     let hash = H256::from_uint(&interpreter.stack()[1]);
-    let expected_state_trie_hash = trie_inputs.state_trie.hash();
+    let expected_state_trie_hash = trie_inputs.state_trie.state.unwrap_left().root();
     assert_eq!(hash, expected_state_trie_hash);
 
     Ok(())
diff --git a/evm_arithmetization/src/cpu/kernel/tests/mpt/insert.rs b/evm_arithmetization/src/cpu/kernel/tests/mpt/insert.rs
index 7428044d1..fefefebd0 100644
--- a/evm_arithmetization/src/cpu/kernel/tests/mpt/insert.rs
+++ b/evm_arithmetization/src/cpu/kernel/tests/mpt/insert.rs
@@ -1,4 +1,7 @@
+use std::collections::BTreeMap;
+
 use anyhow::Result;
+use either::Either;
 use ethereum_types::{BigEndianHash, H256};
 use mpt_trie::nibbles::Nibbles;
 use mpt_trie::partial_trie::{HashedPartialTrie, PartialTrie};
@@ -12,10 +15,12 @@ use crate::cpu::kernel::tests::account_code::initialize_mpts;
 use crate::cpu::kernel::tests::mpt::{
     nibbles_64, nibbles_count, test_account_1_rlp, test_account_2,
 };
-use crate::generation::mpt::AccountRlp;
+use crate::generation::mpt::MptAccount;
 use crate::generation::TrieInputs;
 use crate::memory::segments::Segment;
+use crate::tries::StateMpt;
 use crate::util::h2u;
+use crate::world::{StateWorld, Type1World};
 use crate::Node;
 
 #[test]
@@ -161,18 +166,27 @@ fn mpt_insert_branch_to_leaf_same_key() -> Result<()> {
 fn test_state_trie(
     mut state_trie: HashedPartialTrie,
     k: Nibbles,
-    mut account: AccountRlp,
+    mut account: MptAccount,
 ) -> Result<()> {
     assert_eq!(k.count, 64);
 
+    let state_trie_inputs = StateWorld {
+        state: Either::Left(
+            Type1World::new(
+                StateMpt::new_with_inner(state_trie.clone()),
+                BTreeMap::default(),
+            )
+            .unwrap(),
+        ),
+    };
+
     // Ignore any storage_root; see documentation note.
     account.storage_root = HashedPartialTrie::from(Node::Empty).hash();
 
     let trie_inputs = TrieInputs {
-        state_trie: state_trie.clone(),
+        state_trie: state_trie_inputs,
         transactions_trie: Default::default(),
         receipts_trie: Default::default(),
-        storage_tries: vec![],
     };
     let mpt_insert_state_trie = KERNEL.global_labels["mpt_insert_state_trie"];
     let check_state_trie = KERNEL.global_labels["check_final_state_trie"];
diff --git a/evm_arithmetization/src/cpu/kernel/tests/mpt/linked_list.rs b/evm_arithmetization/src/cpu/kernel/tests/mpt/linked_list.rs
index b31c05233..7ea7355aa 100644
--- a/evm_arithmetization/src/cpu/kernel/tests/mpt/linked_list.rs
+++ b/evm_arithmetization/src/cpu/kernel/tests/mpt/linked_list.rs
@@ -14,13 +14,17 @@ use crate::cpu::kernel::constants::global_metadata::GlobalMetadata;
 use crate::cpu::kernel::interpreter::Interpreter;
 use crate::generation::linked_list::testing::LinkedList;
 use crate::generation::linked_list::ACCOUNTS_LINKED_LIST_NODE_SIZE;
+use crate::generation::linked_list::STATE_LINKED_LIST_NODE_SIZE;
+#[cfg(not(feature = "cdk_erigon"))]
 use crate::generation::linked_list::STORAGE_LINKED_LIST_NODE_SIZE;
 use crate::memory::segments::Segment;
 use crate::witness::memory::MemoryAddress;
 use crate::witness::memory::MemorySegmentState;
 
 pub(crate) type AccountsLinkedList<'a> = LinkedList<'a, ACCOUNTS_LINKED_LIST_NODE_SIZE>;
+#[cfg(not(feature = "cdk_erigon"))]
 pub(crate) type StorageLinkedList<'a> = LinkedList<'a, STORAGE_LINKED_LIST_NODE_SIZE>;
+pub(crate) type StateLinkedList<'a> = LinkedList<'a, STATE_LINKED_LIST_NODE_SIZE>;
 
 fn init_logger() {
     let _ = try_init_from_env(Env::default().filter_or(DEFAULT_FILTER_ENV, "debug"));
@@ -108,23 +112,27 @@ fn test_list_iterator() -> Result<()> {
         .generation_state
         .memory
         .get_preinit_memory(Segment::StorageLinkedList);
-    let mut storage_list =
-        StorageLinkedList::from_mem_and_segment(&accounts_mem, Segment::StorageLinkedList).unwrap();
-    let Some([addr, key, ptr, ptr_cpy, scaled_pos_1]) = storage_list.next() else {
-        return Err(anyhow::Error::msg("Couldn't get value"));
-    };
-    assert_eq!(addr, U256::MAX);
-    assert_eq!(key, U256::zero());
-    assert_eq!(ptr, U256::zero());
-    assert_eq!(ptr_cpy, U256::zero());
-    assert_eq!(scaled_pos_1, (Segment::StorageLinkedList as usize).into());
-    let Some([addr, _key, ptr, ptr_cpy, scaled_pos_1]) = storage_list.next() else {
-        return Err(anyhow::Error::msg("Couldn't get value"));
-    };
-    assert_eq!(addr, U256::MAX);
-    assert_eq!(ptr, U256::zero());
-    assert_eq!(ptr_cpy, U256::zero());
-    assert_eq!(scaled_pos_1, (Segment::StorageLinkedList as usize).into());
+    #[cfg(not(feature = "cdk_erigon"))]
+    {
+        let mut storage_list =
+            StorageLinkedList::from_mem_and_segment(&accounts_mem, Segment::StorageLinkedList)
+                .unwrap();
+        let Some([addr, key, ptr, ptr_cpy, scaled_pos_1]) = storage_list.next() else {
+            return Err(anyhow::Error::msg("Couldn't get value"));
+        };
+        assert_eq!(key, U256::zero());
+        let Some([addr, _key, ptr, ptr_cpy, scaled_pos_1]) = storage_list.next() else {
+            return Err(anyhow::Error::msg("Couldn't get value"));
+        };
+        assert_eq!(addr, U256::MAX);
+        assert_eq!(ptr, U256::zero());
+        assert_eq!(ptr_cpy, U256::zero());
+        assert_eq!(scaled_pos_1, (Segment::StorageLinkedList as usize).into());
+        assert_eq!(addr, U256::MAX);
+        assert_eq!(ptr, U256::zero());
+        assert_eq!(ptr_cpy, U256::zero());
+        assert_eq!(scaled_pos_1, (Segment::StorageLinkedList as usize).into());
+    }
 
     Ok(())
 }
@@ -212,6 +220,7 @@ fn test_insert_account() -> Result<()> {
 }
 
 #[test]
+#[cfg(not(feature = "cdk_erigon"))]
 fn test_insert_storage() -> Result<()> {
     init_logger();
 
@@ -234,7 +243,7 @@ fn test_insert_storage() -> Result<()> {
         (Segment::StorageLinkedList as usize + init_len).into(),
     );
 
-    let insert_account_label = KERNEL.global_labels["insert_slot"];
+    let insert_slot_label = KERNEL.global_labels["insert_slot"];
 
     let retaddr = 0xdeadbeefu32.into();
     let mut rng = thread_rng();
@@ -256,10 +265,10 @@ fn test_insert_storage() -> Result<()> {
     interpreter
         .push(U256::from(address.0.as_slice()))
         .expect("The stack should not overflow");
-    interpreter.generation_state.registers.program_counter = insert_account_label;
+    interpreter.generation_state.registers.program_counter = insert_slot_label;
 
     interpreter.run()?;
-    assert_eq!(interpreter.stack(), &[payload_ptr]);
+    assert_eq!(interpreter.stack(), &[]);
 
     let accounts_mem = interpreter
         .generation_state
@@ -268,6 +277,8 @@ fn test_insert_storage() -> Result<()> {
     let mut list =
         StorageLinkedList::from_mem_and_segment(&accounts_mem, Segment::StorageLinkedList).unwrap();
 
+    log::debug!("ll = {:?}", list);
+
     let Some([inserted_addr, inserted_key, ptr, ptr_cpy, _]) = list.next() else {
         return Err(anyhow::Error::msg("Couldn't get value"));
     };
@@ -283,7 +294,7 @@ fn test_insert_storage() -> Result<()> {
     assert_eq!(inserted_addr, U256::from(address.0.as_slice()));
     assert_eq!(inserted_key, U256::from(key.0.as_slice()));
     assert_eq!(ptr, payload_ptr);
-    assert_eq!(ptr_cpy, U256::zero()); // ptr_cpy is zero because the trie data segment is empty
+    assert_eq!(ptr_cpy, payload_ptr);
     assert_eq!(
         scaled_next_pos,
         (Segment::StorageLinkedList as usize).into()
@@ -487,6 +498,7 @@ fn test_insert_and_delete_accounts() -> Result<()> {
 }
 
 #[test]
+#[cfg(not(feature = "cdk_erigon"))]
 fn test_insert_and_delete_storage() -> Result<()> {
     init_logger();
 
@@ -520,8 +532,6 @@ fn test_insert_and_delete_storage() -> Result<()> {
                 H160::from_low_u64_be(i as u64 + 6),
             ]
         })
-        .collect::<HashSet<_>>()
-        .into_iter()
         .collect::<Vec<[H160; 2]>>();
     let delta_ptr = 100;
     let addr_not_in_list = Address::from_low_u64_be(4);
@@ -549,16 +559,28 @@ fn test_insert_and_delete_storage() -> Result<()> {
             .expect("The stack should not overflow");
         interpreter.generation_state.registers.program_counter = insert_slot_label;
         interpreter.run()?;
+        assert_eq!(interpreter.stack(), &[]);
+
+        let mem = interpreter
+            .generation_state
+            .memory
+            .get_preinit_memory(Segment::StorageLinkedList);
+        log::debug!(
+            "for i = {i} storage linked list = {:?}",
+            StorageLinkedList::from_mem_and_segment(&mem, Segment::StorageLinkedList)
+        );
+
         assert_eq!(
-            interpreter.pop().expect("The stack can't be empty"),
-            addr + delta_ptr
+            interpreter.generation_state.memory.get_with_init(
+                MemoryAddress::new_bundle(U256::from(offset + 5 * (i + 1) + 2)).unwrap(),
+            ),
+            (addr + delta_ptr).into()
         );
-        // The ptr_cpy must be 0
         assert_eq!(
             interpreter.generation_state.memory.get_with_init(
                 MemoryAddress::new_bundle(U256::from(offset + 5 * (i + 1) + 3)).unwrap(),
             ),
-            i.into()
+            (addr + delta_ptr).into()
         );
     }
 
@@ -592,15 +614,18 @@ fn test_insert_and_delete_storage() -> Result<()> {
         interpreter.generation_state.registers.program_counter = insert_slot_label;
         interpreter.run()?;
 
+        assert_eq!(interpreter.stack(), &[]);
         assert_eq!(
-            interpreter.pop().expect("The stack can't be empty"),
-            addr_in_list + delta_ptr
+            interpreter.generation_state.memory.get_with_init(
+                MemoryAddress::new_bundle(U256::from(offset + 5 * (i + 1) + 2)).unwrap(),
+            ),
+            (addr_in_list + delta_ptr).into()
         );
         assert_eq!(
             interpreter.generation_state.memory.get_with_init(
                 MemoryAddress::new_bundle(U256::from(offset + 5 * (i + 1) + 3)).unwrap(),
             ),
-            i.into()
+            (addr_in_list + delta_ptr).into()
         );
     }
 
@@ -621,10 +646,7 @@ fn test_insert_and_delete_storage() -> Result<()> {
 
     interpreter.run()?;
 
-    assert_eq!(
-        interpreter.pop().expect("The stack can't be empty"),
-        U256::from(addr_not_in_list.0.as_slice()) + delta_ptr
-    );
+    assert_eq!(interpreter.stack(), &[]);
 
     // Now the list of accounts have [4, 5]
     addresses_and_keys.push([addr_not_in_list, key_not_in_list]);
diff --git a/evm_arithmetization/src/cpu/kernel/tests/mpt/load.rs b/evm_arithmetization/src/cpu/kernel/tests/mpt/load.rs
index 9d04700bf..8b0a280b4 100644
--- a/evm_arithmetization/src/cpu/kernel/tests/mpt/load.rs
+++ b/evm_arithmetization/src/cpu/kernel/tests/mpt/load.rs
@@ -1,6 +1,8 @@
+use std::collections::BTreeMap;
 use std::str::FromStr;
 
 use anyhow::Result;
+use either::Either;
 use ethereum_types::{BigEndianHash, H256, U256};
 use hex_literal::hex;
 use mpt_trie::nibbles::Nibbles;
@@ -13,6 +15,9 @@ use crate::cpu::kernel::interpreter::Interpreter;
 use crate::cpu::kernel::tests::account_code::initialize_mpts;
 use crate::cpu::kernel::tests::mpt::{extension_to_leaf, test_account_1, test_account_1_rlp};
 use crate::generation::TrieInputs;
+use crate::testing_utils::get_state_world;
+use crate::tries::StateMpt;
+use crate::world::{StateWorld, Type1World};
 use crate::Node;
 
 #[test]
@@ -21,7 +26,6 @@ fn load_all_mpts_empty() -> Result<()> {
         state_trie: Default::default(),
         transactions_trie: Default::default(),
         receipts_trie: Default::default(),
-        storage_tries: vec![],
     };
 
     let initial_stack = vec![];
@@ -50,15 +54,21 @@ fn load_all_mpts_empty() -> Result<()> {
 
 #[test]
 fn load_all_mpts_leaf() -> Result<()> {
-    let trie_inputs = TrieInputs {
-        state_trie: Node::Leaf {
-            nibbles: 0xABC_u64.into(),
+    let state_trie = get_state_world(
+        Node::Leaf {
+            nibbles: Nibbles {
+                count: 64,
+                packed: 0xABC_u64.into(),
+            },
             value: test_account_1_rlp(),
         }
         .into(),
+        vec![],
+    );
+    let trie_inputs = TrieInputs {
+        state_trie,
         transactions_trie: Default::default(),
         receipts_trie: Default::default(),
-        storage_tries: vec![],
     };
 
     let initial_stack = vec![];
@@ -78,7 +88,7 @@ fn load_all_mpts_leaf() -> Result<()> {
             test_account_1().code_hash.into_uint(),
             // Values used for hashing.
             type_leaf,
-            3.into(),
+            64.into(), // should be 3 nibbles but keys are extended for `Type1World`
             0xABC.into(),
             9.into(), // value ptr
             test_account_1().nonce,
@@ -106,11 +116,21 @@ fn load_all_mpts_leaf() -> Result<()> {
 #[test]
 fn load_all_mpts_hash() -> Result<()> {
     let hash = H256::random();
+
+    let state_trie = StateWorld {
+        state: Either::Left(
+            Type1World::new(
+                StateMpt::new_with_inner(Node::Hash(hash).into()),
+                BTreeMap::default(),
+            )
+            .unwrap(),
+        ),
+    };
+
     let trie_inputs = TrieInputs {
-        state_trie: Node::Hash(hash).into(),
+        state_trie,
         transactions_trie: Default::default(),
         receipts_trie: Default::default(),
-        storage_tries: vec![],
     };
 
     let initial_stack = vec![];
@@ -139,16 +159,25 @@ fn load_all_mpts_hash() -> Result<()> {
 #[test]
 fn load_all_mpts_empty_branch() -> Result<()> {
     let children = core::array::from_fn(|_| Node::Empty.into());
-    let state_trie = Node::Branch {
-        children,
-        value: vec![],
-    }
-    .into();
+    let state_trie = StateWorld {
+        state: Either::Left(
+            Type1World::new(
+                StateMpt::new_with_inner(
+                    Node::Branch {
+                        children,
+                        value: vec![],
+                    }
+                    .into(),
+                ),
+                BTreeMap::default(),
+            )
+            .unwrap(),
+        ),
+    };
     let trie_inputs = TrieInputs {
         state_trie,
         transactions_trie: Default::default(),
         receipts_trie: Default::default(),
-        storage_tries: vec![],
     };
 
     let initial_stack = vec![];
@@ -197,10 +226,9 @@ fn load_all_mpts_empty_branch() -> Result<()> {
 #[test]
 fn load_all_mpts_ext_to_leaf() -> Result<()> {
     let trie_inputs = TrieInputs {
-        state_trie: extension_to_leaf(test_account_1_rlp()),
+        state_trie: get_state_world(extension_to_leaf(test_account_1_rlp()), vec![]),
         transactions_trie: Default::default(),
         receipts_trie: Default::default(),
-        storage_tries: vec![],
     };
 
     let initial_stack = vec![];
@@ -221,11 +249,11 @@ fn load_all_mpts_ext_to_leaf() -> Result<()> {
             test_account_1().code_hash.into_uint(),
             // Values used for hashing.
             type_extension,
-            3.into(),     // 3 nibbles
+            61.into(),    // The extension node has 61 nibbles
             0xABC.into(), // key part
             9.into(),     // Pointer to the leaf node immediately below.
             type_leaf,
-            3.into(),     // 3 nibbles
+            3.into(),     // The remaining 3 nibbles
             0xDEF.into(), // key part
             13.into(),    // value pointer
             test_account_1().nonce,
@@ -252,7 +280,6 @@ fn load_mpt_txn_trie() -> Result<()> {
             value: txn.clone(),
         }),
         receipts_trie: Default::default(),
-        storage_tries: vec![],
     };
 
     let initial_stack = vec![];
diff --git a/evm_arithmetization/src/cpu/kernel/tests/mpt/mod.rs b/evm_arithmetization/src/cpu/kernel/tests/mpt/mod.rs
index 17ff18a9b..57cde19ca 100644
--- a/evm_arithmetization/src/cpu/kernel/tests/mpt/mod.rs
+++ b/evm_arithmetization/src/cpu/kernel/tests/mpt/mod.rs
@@ -1,17 +1,25 @@
+use either::Either;
 use ethereum_types::{BigEndianHash, H256, U256};
 use mpt_trie::nibbles::Nibbles;
 use mpt_trie::partial_trie::HashedPartialTrie;
 use mpt_trie::partial_trie::PartialTrie;
 
-use crate::generation::mpt::AccountRlp;
+use crate::generation::mpt::EitherAccount;
+use crate::generation::mpt::MptAccount;
+use crate::generation::mpt::{Account, SmtAccount};
 use crate::Node;
 
+#[cfg(not(feature = "cdk_erigon"))]
 mod delete;
+#[cfg(not(feature = "cdk_erigon"))]
 mod hash;
 mod hex_prefix;
+#[cfg(not(feature = "cdk_erigon"))]
 mod insert;
-mod linked_list;
+pub(crate) mod linked_list;
+#[cfg(not(feature = "cdk_erigon"))]
 mod load;
+#[cfg(not(feature = "cdk_erigon"))]
 mod read;
 
 pub(crate) fn nibbles_64<T: Into<U256>>(v: T) -> Nibbles {
@@ -30,34 +38,46 @@ pub(crate) fn nibbles_count<T: Into<U256>>(v: T, count: usize) -> Nibbles {
     }
 }
 
-pub(crate) fn test_account_1() -> AccountRlp {
-    AccountRlp {
-        nonce: U256::from(1111),
-        balance: U256::from(2222),
-        storage_root: H256::from_uint(&U256::from(3333)),
-        code_hash: H256::from_uint(&U256::from(4444)),
+pub(crate) fn test_account_1_empty_storage() -> EitherAccount {
+    if cfg!(feature = "cdk_erigon") {
+        EitherAccount(Either::Right(SmtAccount {
+            nonce: U256::from(1111),
+            balance: U256::from(2222),
+            code_hash: U256::from(4444),
+            code_length: 0.into(),
+        }))
+    } else {
+        EitherAccount(Either::Left(MptAccount {
+            nonce: U256::from(1111),
+            balance: U256::from(2222),
+            storage_root: HashedPartialTrie::from(Node::Empty).hash(),
+            code_hash: H256::from_uint(&U256::from(4444)),
+        }))
     }
 }
 
-pub(crate) fn test_account_1_empty_storage() -> AccountRlp {
-    AccountRlp {
+#[cfg(not(feature = "cdk_erigon"))]
+pub(crate) fn test_account_1() -> MptAccount {
+    MptAccount {
         nonce: U256::from(1111),
         balance: U256::from(2222),
-        storage_root: HashedPartialTrie::from(Node::Empty).hash(),
+        storage_root: H256::from_uint(&U256::from(3333)),
         code_hash: H256::from_uint(&U256::from(4444)),
     }
 }
 
+#[cfg(not(feature = "cdk_erigon"))]
 pub(crate) fn test_account_1_rlp() -> Vec<u8> {
-    rlp::encode(&test_account_1()).to_vec()
+    test_account_1().rlp_encode().to_vec()
 }
 
 pub(crate) fn test_account_1_empty_storage_rlp() -> Vec<u8> {
-    rlp::encode(&test_account_1_empty_storage()).to_vec()
+    test_account_1_empty_storage().rlp_encode().to_vec()
 }
 
-pub(crate) fn test_account_2() -> AccountRlp {
-    AccountRlp {
+#[cfg(not(feature = "cdk_erigon"))]
+pub(crate) fn test_account_2() -> MptAccount {
+    MptAccount {
         nonce: U256::from(5555),
         balance: U256::from(6666),
         storage_root: H256::from_uint(&U256::from(7777)),
@@ -65,15 +85,19 @@ pub(crate) fn test_account_2() -> AccountRlp {
     }
 }
 
+#[cfg(not(feature = "cdk_erigon"))]
 pub(crate) fn test_account_2_rlp() -> Vec<u8> {
-    rlp::encode(&test_account_2()).to_vec()
+    test_account_2().rlp_encode().to_vec()
 }
 
 /// A `PartialTrie` where an extension node leads to a leaf node containing an
 /// account.
 pub(crate) fn extension_to_leaf(value: Vec<u8>) -> HashedPartialTrie {
     Node::Extension {
-        nibbles: 0xABC_u64.into(),
+        nibbles: Nibbles {
+            count: 61,
+            packed: 0xABC_u64.into(),
+        },
         child: Node::Leaf {
             nibbles: Nibbles {
                 count: 3,
diff --git a/evm_arithmetization/src/cpu/kernel/tests/mpt/read.rs b/evm_arithmetization/src/cpu/kernel/tests/mpt/read.rs
index 8390c6a59..6e1a87567 100644
--- a/evm_arithmetization/src/cpu/kernel/tests/mpt/read.rs
+++ b/evm_arithmetization/src/cpu/kernel/tests/mpt/read.rs
@@ -8,16 +8,19 @@ use crate::cpu::kernel::interpreter::Interpreter;
 use crate::cpu::kernel::tests::account_code::initialize_mpts;
 use crate::cpu::kernel::tests::mpt::{extension_to_leaf, test_account_1, test_account_1_rlp};
 use crate::generation::TrieInputs;
+use crate::testing_utils::{get_state_world, init_logger};
 
 #[test]
 fn mpt_read() -> Result<()> {
+    init_logger();
     let trie_inputs = TrieInputs {
-        state_trie: extension_to_leaf(test_account_1_rlp()),
+        state_trie: get_state_world(extension_to_leaf(test_account_1_rlp()), vec![]),
         transactions_trie: Default::default(),
         receipts_trie: Default::default(),
-        storage_tries: vec![],
     };
 
+    log::debug!("state trie: {:?}", trie_inputs.state_trie);
+
     let mpt_read = KERNEL.global_labels["mpt_read"];
 
     let initial_stack = vec![];
@@ -34,7 +37,7 @@ fn mpt_read() -> Result<()> {
         .push(0xABCDEFu64.into())
         .expect("The stack should not overflow");
     interpreter
-        .push(6.into())
+        .push(64.into())
         .expect("The stack should not overflow");
     interpreter
         .push(interpreter.get_global_metadata_field(GlobalMetadata::StateTrieRoot))
@@ -42,8 +45,9 @@ fn mpt_read() -> Result<()> {
     interpreter.run()?;
 
     assert_eq!(interpreter.stack().len(), 1);
-    // mpt_read returns a pointer to the accounts pointer
+    // mpt_read returns a pointer to a pointer to the accounts pointer
     let result_ptr_ptr = interpreter.stack()[0].as_usize();
+    log::debug!("el ptr = {result_ptr_ptr}");
     let result_ptr = interpreter.get_trie_data()[result_ptr_ptr..][..4][0].as_usize();
     let result = &interpreter.get_trie_data()[result_ptr..][..4];
     assert_eq!(result[0], test_account_1().nonce);
diff --git a/evm_arithmetization/src/cpu/kernel/tests/receipt.rs b/evm_arithmetization/src/cpu/kernel/tests/receipt.rs
index 6482cfd59..34c7a8003 100644
--- a/evm_arithmetization/src/cpu/kernel/tests/receipt.rs
+++ b/evm_arithmetization/src/cpu/kernel/tests/receipt.rs
@@ -19,7 +19,7 @@ fn test_process_receipt() -> Result<()> {
     /* Tests process_receipt, which:
     - computes the cumulative gas
     - computes the bloom filter
-    - inserts the receipt data in MPT_TRIE_DATA
+    - inserts the receipt data in TRIE_DATA
     - inserts a node in receipt_trie
     - resets the bloom filter to 0 for the next transaction. */
     let process_receipt = KERNEL.global_labels["process_receipt"];
diff --git a/evm_arithmetization/src/cpu/kernel/tests/transaction_parsing/parse_type_3_txn.rs b/evm_arithmetization/src/cpu/kernel/tests/transaction_parsing/parse_type_3_txn.rs
index b80a3772a..d605a133c 100644
--- a/evm_arithmetization/src/cpu/kernel/tests/transaction_parsing/parse_type_3_txn.rs
+++ b/evm_arithmetization/src/cpu/kernel/tests/transaction_parsing/parse_type_3_txn.rs
@@ -1,4 +1,5 @@
 use anyhow::Result;
+use either::Either;
 use ethereum_types::{Address, U256};
 use hex_literal::hex;
 use keccak_hash::H256;
@@ -10,18 +11,18 @@ use crate::cpu::kernel::constants::txn_fields::NormalizedTxnField;
 use crate::cpu::kernel::interpreter::Interpreter;
 use crate::cpu::kernel::tests::account_code::prepare_interpreter;
 use crate::cpu::kernel::tests::transaction_parsing::prepare_interpreter_for_txn_parsing;
-use crate::generation::mpt::AccountRlp;
+use crate::generation::mpt::{EitherAccount, MptAccount};
 use crate::testing_utils::EMPTY_NODE_HASH;
 
 #[test]
 fn process_type_3_txn() -> Result<()> {
     let sender_address = Address::from_slice(&hex!("a94f5374fce5edbc8e2a8697c15331677e6ebf0b"));
-    let sender_account = AccountRlp {
+    let sender_account = EitherAccount(Either::Left(MptAccount {
         nonce: 1.into(),
         balance: 0x1000000.into(),
         storage_root: EMPTY_NODE_HASH,
         code_hash: H256::default(),
-    };
+    }));
 
     let mut interpreter: Interpreter<F> = Interpreter::new(0, vec![], None);
     // Prepare the interpreter by inserting the sender account in the state trie.
@@ -107,12 +108,12 @@ fn process_type_3_txn() -> Result<()> {
 #[test]
 fn process_type_3_txn_invalid_sig() -> Result<()> {
     let sender_address = Address::from_slice(&hex!("a94f5374fce5edbc8e2a8697c15331677e6ebf0b"));
-    let sender_account = AccountRlp {
+    let sender_account = EitherAccount(Either::Left(MptAccount {
         nonce: 1.into(),
         balance: 0x1000000.into(),
         storage_root: EMPTY_NODE_HASH,
         code_hash: H256::default(),
-    };
+    }));
 
     let mut interpreter: Interpreter<F> = Interpreter::new(0, vec![], None);
     // Prepare the interpreter by inserting the sender account in the state trie.
diff --git a/evm_arithmetization/src/cpu/kernel/tests/transient_storage.rs b/evm_arithmetization/src/cpu/kernel/tests/transient_storage.rs
index e874b9ca6..f8b644adb 100644
--- a/evm_arithmetization/src/cpu/kernel/tests/transient_storage.rs
+++ b/evm_arithmetization/src/cpu/kernel/tests/transient_storage.rs
@@ -13,6 +13,7 @@ use crate::cpu::kernel::constants::global_metadata::GlobalMetadata;
 use crate::cpu::kernel::interpreter::Interpreter;
 use crate::generation::state::GenerationState;
 use crate::memory::segments::Segment;
+use crate::testing_utils::init_logger;
 use crate::witness::memory::MemoryAddress;
 use crate::GenerationInputs;
 
@@ -220,6 +221,7 @@ fn test_many_tstore_many_tload() -> Result<()> {
 
 #[test]
 fn test_revert() -> Result<()> {
+    init_logger();
     // We use a modified kernel with an extra file defining a label
     // where the `checkpoint` macro from file cpu/kernel/asm/journal/journal.asm
     // is expanded.
@@ -268,6 +270,8 @@ fn test_revert() -> Result<()> {
 
     let gas_before_checkpoint = interpreter.generation_state.registers.gas_used;
 
+    log::debug!("Saperlipopete");
+
     // We will revert to the point where `val` was 9
     let checkpoint = TEST_KERNEL.global_labels["checkpoint"];
     interpreter.generation_state.registers.program_counter = checkpoint;
@@ -323,6 +327,8 @@ fn test_revert() -> Result<()> {
         .push(kexit_info)
         .expect("The stack should not overflow");
     assert!(interpreter.run().is_err());
+    
+    log::debug!("Yubigobinabi");
 
     // Now we should load the value before the revert
     let sys_tload = TEST_KERNEL.global_labels["sys_tload"];
diff --git a/evm_arithmetization/src/generation/linked_list.rs b/evm_arithmetization/src/generation/linked_list.rs
index b2465bb88..d09ddcd3b 100644
--- a/evm_arithmetization/src/generation/linked_list.rs
+++ b/evm_arithmetization/src/generation/linked_list.rs
@@ -3,40 +3,66 @@ use std::collections::BTreeMap;
 use ethereum_types::U256;
 use serde::{Deserialize, Serialize};
 
-use crate::memory::segments::Segment;
-
 pub const ACCOUNTS_LINKED_LIST_NODE_SIZE: usize = 4;
+#[cfg(not(feature = "cdk_erigon"))]
 pub const STORAGE_LINKED_LIST_NODE_SIZE: usize = 5;
+pub const STATE_LINKED_LIST_NODE_SIZE: usize = 4;
 
 pub const DUMMYHEAD: (U256, U256) = (U256::MAX, U256::zero());
 
 // Provides quick access to pointers that reference the memory location
 // of a storage or accounts linked list node, containing a specific key.
 #[derive(Debug, Clone, Default, Serialize, Deserialize)]
-pub(crate) struct LinkedListsPtrs {
+pub(crate) struct AccessLinkedListsPtrs {
+    /// Each entry contains the pair (key, ptr) where key is the (hashed) key
+    /// of an account in the accounts linked list, and ptr is the respective
+    /// node address in memory.
+    pub(crate) accounts_pointers: BTreeMap<U256, usize>,
+    /// Each entry contains the pair ((account_key, slot_key), ptr) where
+    /// account_key is the (hashed) key of an account, slot_key is the slot
+    /// key, and ptr is the respective node address in memory.
+    pub(crate) storage_pointers: BTreeMap<(U256, U256), usize>,
+}
+
+// Provides quick access to pointers that reference the memory location
+// of state nodes.
+#[derive(Debug, Clone, Default, Serialize, Deserialize)]
+#[cfg(not(feature = "cdk_erigon"))]
+pub(crate) struct StateLinkedListsPtrs {
     /// Each entry contains the pair (key, ptr) where key is the (hashed) key
     /// of an account in the accounts linked list, and ptr is the respective
     /// node address in memory.
-    pub(crate) accounts: BTreeMap<U256, usize>,
+    pub(crate) accounts_pointers: BTreeMap<U256, usize>,
     /// Each entry contains the pair ((account_key, slot_key), ptr) where
     /// account_key is the (hashed) key of an account, slot_key is the slot
     /// key, and ptr is the respective node address in memory.
-    pub(crate) storage: BTreeMap<(U256, U256), usize>,
+    pub(crate) storage_pointers: BTreeMap<(U256, U256), usize>,
+}
+
+// Provides quick access to pointers that reference the memory location
+// of state nodes.
+#[derive(Debug, Clone, Default, Serialize, Deserialize)]
+#[cfg(feature = "cdk_erigon")]
+pub(crate) struct StateLinkedListsPtrs {
+    /// Each entry contains the pair (key, ptr) where key is the (hashed) key
+    /// of an account in the accounts linked list, and ptr is the respective
+    /// node address in memory.
+    pub(crate) state: BTreeMap<U256, usize>,
 }
 
-pub(crate) fn empty_list_mem<const N: usize>(segment: Segment) -> [Option<U256>; N] {
+pub(crate) fn empty_list_mem<const N: usize>(offset: usize) -> [Option<U256>; N] {
     std::array::from_fn(|i| {
         if i == 0 {
             Some(U256::MAX)
         } else if i == N - 1 {
-            Some((segment as usize).into())
+            Some(U256::from(offset))
         } else {
             Some(U256::zero())
         }
     })
 }
 
-#[cfg(test)]
+// #[cfg(test)]
 pub(crate) mod testing {
     use std::fmt;
     use std::marker::PhantomData;
@@ -44,6 +70,7 @@ pub(crate) mod testing {
     use anyhow::Result;
 
     use super::*;
+    use crate::memory::segments::Segment;
     use crate::util::u256_to_usize;
     use crate::witness::errors::ProgramError;
     use crate::witness::errors::ProverInputError::InvalidInput;
diff --git a/evm_arithmetization/src/generation/mod.rs b/evm_arithmetization/src/generation/mod.rs
index 023e1f2ac..80615c5cb 100644
--- a/evm_arithmetization/src/generation/mod.rs
+++ b/evm_arithmetization/src/generation/mod.rs
@@ -3,6 +3,7 @@ use std::fmt::Display;
 
 use anyhow::anyhow;
 use ethereum_types::{Address, BigEndianHash, H256, U256};
+use itertools::Either;
 use keccak_hash::keccak;
 use log::error;
 use mpt_trie::partial_trie::{HashedPartialTrie, PartialTrie};
@@ -13,6 +14,7 @@ use plonky2::timed;
 use plonky2::util::timing::TimingTree;
 use segments::GenerationSegmentData;
 use serde::{Deserialize, Serialize};
+use smt_trie::smt::hash_serialize_u256;
 use starky::config::StarkConfig;
 use GlobalMetadata::{
     ReceiptTrieRootDigestAfter, ReceiptTrieRootDigestBefore, StateTrieRootDigestAfter,
@@ -25,7 +27,9 @@ use crate::cpu::columns::CpuColumnsView;
 use crate::cpu::kernel::aggregator::KERNEL;
 use crate::cpu::kernel::constants::global_metadata::GlobalMetadata;
 use crate::generation::state::{GenerationState, State};
-use crate::generation::trie_extractor::{get_receipt_trie, get_state_trie, get_txn_trie};
+#[cfg(not(feature = "cdk_erigon"))]
+use crate::generation::trie_extractor::get_state_trie;
+use crate::generation::trie_extractor::{get_receipt_trie, get_txn_trie};
 use crate::memory::segments::{Segment, PREINITIALIZED_SEGMENTS_INDICES};
 use crate::proof::{
     BlockHashes, BlockMetadata, ExtraBlockData, MemCap, PublicValues, RegistersData, TrieRoots,
@@ -33,6 +37,7 @@ use crate::proof::{
 use crate::util::{h2u, u256_to_usize};
 use crate::witness::memory::{MemoryAddress, MemoryChannel, MemoryState};
 use crate::witness::state::RegistersState;
+use crate::world::StateWorld;
 
 pub(crate) mod linked_list;
 pub mod mpt;
@@ -183,12 +188,19 @@ pub struct TrimmedGenerationInputs<F: RichField> {
     pub block_hashes: BlockHashes,
 }
 
+#[cfg(feature = "cdk_erigon")]
+type SmtTrie = smt_trie::smt::Smt<smt_trie::db::MemoryDb>;
+
 #[derive(Clone, Debug, Deserialize, Serialize, Default)]
 pub struct TrieInputs {
     /// A partial version of the state trie prior to these transactions. It
     /// should include all nodes that will be accessed by these
+    /// transactions. In "eth_mainnet", it also contains the storage trie prior
+    /// to these transactions (including all storage tries, and nodes therein,
+    /// that will be accessed by these transactions). In "eth_mainnet", it also
+    /// includes a partial version of each storage trie prior to these
     /// transactions.
-    pub state_trie: HashedPartialTrie,
+    pub state_trie: StateWorld,
 
     /// A partial version of the transaction trie prior to these transactions.
     /// It should include all nodes that will be accessed by these
@@ -199,33 +211,25 @@ pub struct TrieInputs {
     /// should include all nodes that will be accessed by these
     /// transactions.
     pub receipts_trie: HashedPartialTrie,
-
-    /// A partial version of each storage trie prior to these transactions. It
-    /// should include all storage tries, and nodes therein, that will be
-    /// accessed by these transactions.
-    pub storage_tries: Vec<(H256, HashedPartialTrie)>,
 }
 
 #[derive(Clone, Debug, Deserialize, Serialize, Default)]
 pub struct TrimmedTrieInputs {
     /// A partial version of the state trie prior to these transactions. It
     /// should include all nodes that will be accessed by these
-    /// transactions.
-    pub state_trie: HashedPartialTrie,
-    /// A partial version of each storage trie prior to these transactions. It
-    /// should include all storage tries, and nodes therein, that will be
-    /// accessed by these transactions.
-    pub storage_tries: Vec<(H256, HashedPartialTrie)>,
+    /// transactions. In "eth_mainnet", it also contains the storage trie prior
+    /// to these transactions.
+    pub state_trie: StateWorld,
 }
 
 impl TrieInputs {
     pub(crate) fn trim(&self) -> TrimmedTrieInputs {
         TrimmedTrieInputs {
             state_trie: self.state_trie.clone(),
-            storage_tries: self.storage_tries.clone(),
         }
     }
 }
+
 impl<F: RichField> GenerationInputs<F> {
     /// Outputs a trimmed version of the `GenerationInputs`, that do not contain
     /// the fields that have already been processed during pre-initialization,
@@ -237,6 +241,14 @@ impl<F: RichField> GenerationInputs<F> {
             .map(|tx_bytes| keccak(&tx_bytes[..]))
             .collect();
 
+        let state_root = match &self.tries.state_trie.state {
+            Either::Left(trie) => trie.state_trie().hash(),
+            Either::Right(trie) => {
+                let smt_data = trie.as_smt().to_vec();
+                H256::from_uint(&hash_serialize_u256(&smt_data).into())
+            }
+        };
+
         TrimmedGenerationInputs {
             trimmed_tries: self.tries.trim(),
             txn_number_before: self.txn_number_before,
@@ -244,7 +256,7 @@ impl<F: RichField> GenerationInputs<F> {
             gas_used_after: self.gas_used_after,
             txn_hashes,
             trie_roots_before: TrieRoots {
-                state_root: self.tries.state_trie.hash(),
+                state_root,
                 transactions_root: self.tries.transactions_trie.hash(),
                 receipts_root: self.tries.receipts_trie.hash(),
             },
@@ -440,7 +452,17 @@ pub(crate) fn debug_inputs<F: RichField>(inputs: &GenerationInputs<F>) {
         &inputs.tries.transactions_trie
     );
     log::debug!("Input receipts_trie: {:?}", &inputs.tries.receipts_trie);
-    log::debug!("Input storage_tries: {:?}", &inputs.tries.storage_tries);
+    #[cfg(feature = "eth_mainnet")]
+    log::debug!(
+        "Input storage_tries: {:?}",
+        &inputs
+            .tries
+            .state_trie
+            .state
+            .clone()
+            .expect_left("eth_mainnet expects MPTs")
+            .get_storage()
+    );
     log::debug!("Input contract_code: {:?}", &inputs.contract_code);
 }
 
@@ -680,10 +702,14 @@ pub(crate) fn collect_debug_tries<F: RichField>(
     .inspect_err(|e| error!("failed to retrieve state trie pointer: {e:?}"))
     .ok()?;
 
+    #[cfg(not(feature = "cdk_erigon"))]
     let state_trie = get_state_trie::<HashedPartialTrie>(&state.memory, state_trie_ptr)
         .inspect_err(|e| error!("unable to retrieve state trie for debugging purposes: {e:?}"))
         .ok()?;
 
+    #[cfg(feature = "cdk_erigon")]
+    let state_trie = HashedPartialTrie::default();
+
     let txn_trie_ptr = u256_to_usize(
         state
             .memory
diff --git a/evm_arithmetization/src/generation/mpt.rs b/evm_arithmetization/src/generation/mpt.rs
index 85f85e75f..e8ad14ef1 100644
--- a/evm_arithmetization/src/generation/mpt.rs
+++ b/evm_arithmetization/src/generation/mpt.rs
@@ -1,7 +1,9 @@
 use core::ops::Deref;
+use std::any::Any;
 use std::collections::{BTreeMap, HashMap};
 
-use bytes::Bytes;
+use bytes::{Bytes, BytesMut};
+use either::Either;
 use ethereum_types::{Address, BigEndianHash, H256, U256};
 use keccak_hash::keccak;
 use mpt_trie::nibbles::{Nibbles, NibblesIntern};
@@ -10,6 +12,7 @@ use rlp::{Decodable, DecoderError, Encodable, PayloadInfo, Rlp, RlpStream};
 use rlp_derive::{RlpDecodable, RlpEncodable};
 use serde::{Deserialize, Serialize};
 
+#[cfg(not(feature = "cdk_erigon"))]
 use super::linked_list::{
     empty_list_mem, ACCOUNTS_LINKED_LIST_NODE_SIZE, STORAGE_LINKED_LIST_NODE_SIZE,
 };
@@ -22,13 +25,160 @@ use crate::witness::errors::{ProgramError, ProverInputError};
 use crate::Node;
 
 #[derive(RlpEncodable, RlpDecodable, Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
-pub struct AccountRlp {
+pub struct MptAccount {
     pub nonce: U256,
     pub balance: U256,
     pub storage_root: H256,
     pub code_hash: H256,
 }
 
+impl Account for MptAccount {
+    fn get_nonce(&self) -> U256 {
+        self.nonce
+    }
+    fn get_balance(&self) -> U256 {
+        self.balance
+    }
+    fn get_storage_root(&self) -> H256 {
+        self.storage_root
+    }
+    fn get_code_length(&self) -> U256 {
+        panic!("No code length in an MPT's account.")
+    }
+    fn get_code_hash(&self) -> H256 {
+        self.code_hash
+    }
+    fn get_code_hash_u256(&self) -> U256 {
+        self.code_hash.into_uint()
+    }
+    fn rlp_encode(&self) -> BytesMut {
+        rlp::encode(self)
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
+pub struct SmtAccount {
+    pub nonce: U256,
+    pub balance: U256,
+    pub code_length: U256,
+    pub code_hash: U256,
+}
+
+impl Account for SmtAccount {
+    fn get_nonce(&self) -> U256 {
+        self.nonce
+    }
+    fn get_balance(&self) -> U256 {
+        self.balance
+    }
+    fn get_storage_root(&self) -> H256 {
+        panic!("No storage root in an SMT's account.")
+    }
+    fn get_code_length(&self) -> U256 {
+        self.code_length
+    }
+    fn get_code_hash(&self) -> H256 {
+        H256::from_uint(&self.code_hash)
+    }
+    fn get_code_hash_u256(&self) -> U256 {
+        self.code_hash
+    }
+    fn rlp_encode(&self) -> BytesMut {
+        unimplemented!("SMTs do not support RLP encoding.")
+    }
+}
+
+pub trait Account: Any {
+    fn get_nonce(&self) -> U256;
+    fn get_balance(&self) -> U256;
+    fn get_storage_root(&self) -> H256;
+    fn get_code_length(&self) -> U256;
+    fn get_code_hash(&self) -> H256;
+    fn get_code_hash_u256(&self) -> U256;
+    fn rlp_encode(&self) -> BytesMut;
+}
+
+pub struct EitherAccount(pub Either<MptAccount, SmtAccount>);
+
+impl EitherAccount {
+    #[cfg(test)]
+    pub(crate) fn rlp_encode(&self) -> BytesMut {
+        match &self.0 {
+            Either::Left(mpt_acct) => mpt_acct.rlp_encode(),
+            Either::Right(smt_acct) => smt_acct.rlp_encode(),
+        }
+    }
+
+    pub fn as_smt_account(&self) -> &SmtAccount {
+        match &self.0 {
+            Either::Left(_mpt_account_rlp) => panic!("cdk_erigon expects SMTs"),
+            Either::Right(smt_account_rlp) => smt_account_rlp,
+        }
+    }
+
+    pub fn as_mpt_account(&self) -> &MptAccount {
+        match &self.0 {
+            Either::Left(mpt_account_rlp) => mpt_account_rlp,
+            Either::Right(_smt_account_rlp) => panic!("eth_main expects MPTs"),
+        }
+    }
+}
+
+impl Account for EitherAccount {
+    fn get_nonce(&self) -> U256 {
+        match self.0 {
+            Either::Left(mpt_rlp) => mpt_rlp.get_nonce(),
+            Either::Right(smt_rlp) => smt_rlp.get_nonce(),
+        }
+    }
+    fn get_balance(&self) -> U256 {
+        match self.0 {
+            Either::Left(mpt_rlp) => mpt_rlp.get_balance(),
+            Either::Right(smt_rlp) => smt_rlp.get_balance(),
+        }
+    }
+    fn get_storage_root(&self) -> H256 {
+        match self.0 {
+            Either::Left(mpt_rlp) => mpt_rlp.get_storage_root(),
+            Either::Right(smt_rlp) => smt_rlp.get_storage_root(),
+        }
+    }
+    fn get_code_length(&self) -> U256 {
+        match self.0 {
+            Either::Left(mpt_rlp) => mpt_rlp.get_code_length(),
+            Either::Right(smt_rlp) => smt_rlp.get_code_length(),
+        }
+    }
+    fn get_code_hash(&self) -> H256 {
+        match self.0 {
+            Either::Left(mpt_rlp) => mpt_rlp.get_code_hash(),
+            Either::Right(smt_rlp) => smt_rlp.get_code_hash(),
+        }
+    }
+    fn get_code_hash_u256(&self) -> U256 {
+        match self.0 {
+            Either::Left(mpt_rlp) => mpt_rlp.get_code_hash_u256(),
+            Either::Right(smt_rlp) => smt_rlp.get_code_hash_u256(),
+        }
+    }
+    fn rlp_encode(&self) -> BytesMut {
+        match self.0 {
+            Either::Left(mpt_rlp) => mpt_rlp.rlp_encode(),
+            Either::Right(smt_rlp) => smt_rlp.rlp_encode(),
+        }
+    }
+}
+
+impl Default for EitherAccount {
+    fn default() -> Self {
+        EitherAccount(if cfg!(feature = "cdk_erigon") {
+            Either::Right(SmtAccount::default())
+        } else {
+            Either::Left(MptAccount::default())
+        })
+    }
+}
+
 #[derive(Clone, Debug, Default, Serialize, Deserialize)]
 pub struct TrieRootPtrs {
     pub state_root_ptr: Option<usize>,
@@ -36,7 +186,7 @@ pub struct TrieRootPtrs {
     pub receipt_root_ptr: usize,
 }
 
-impl Default for AccountRlp {
+impl Default for MptAccount {
     fn default() -> Self {
         Self {
             nonce: U256::zero(),
@@ -47,6 +197,19 @@ impl Default for AccountRlp {
     }
 }
 
+impl Default for SmtAccount {
+    fn default() -> Self {
+        use smt_trie::code::hash_bytecode_h256;
+
+        Self {
+            nonce: U256::zero(),
+            balance: U256::zero(),
+            code_hash: hash_bytecode_h256(&[]).into_uint(),
+            code_length: U256::zero(),
+        }
+    }
+}
+
 #[derive(RlpEncodable, RlpDecodable, Debug, Clone)]
 pub struct LogRlp {
     pub address: Address,
@@ -155,7 +318,9 @@ where
 {
     let node_ptr = trie_data.len();
     let type_of_trie = PartialTrieType::of(trie) as u32;
+    log::debug!("el trie = {:?}", trie);
     if type_of_trie > 0 {
+        log::debug!("writting {:?} in {:?}", type_of_trie, trie_data.len());
         trie_data.push(Some(type_of_trie.into()));
     }
 
@@ -285,8 +450,8 @@ fn load_state_trie(
             Ok(node_ptr)
         }
         Node::Leaf { nibbles, value } => {
-            let account: AccountRlp = rlp::decode(value).map_err(|_| ProgramError::InvalidRlp)?;
-            let AccountRlp {
+            let account: MptAccount = rlp::decode(value).map_err(|_| ProgramError::InvalidRlp)?;
+            let MptAccount {
                 nonce,
                 balance,
                 storage_root,
@@ -299,6 +464,7 @@ fn load_state_trie(
                 .get(&merged_key)
                 .copied()
                 .unwrap_or(&storage_hash_only);
+            log::debug!("storage tries = {:?}", storage_tries_by_state_key);
 
             assert_eq!(storage_trie.hash(), storage_root,
                 "In TrieInputs, an account's storage_root didn't match the associated storage trie hash");
@@ -316,11 +482,14 @@ fn load_state_trie(
             trie_data.push(Some(balance));
             // Storage trie ptr.
             let storage_ptr_ptr = trie_data.len();
+            log::debug!("pushing storage_ptr = {:?}", storage_ptr_ptr + 2);
             trie_data.push(Some((trie_data.len() + 2).into()));
             trie_data.push(Some(code_hash.into_uint()));
             // We don't need to store the slot values, as they will be overwritten in
             // `mpt_set_payload`.
+            log::debug!("loading storage");
             let storage_ptr = load_mpt(storage_trie, trie_data, &parse_storage_value_no_return)?;
+            log::debug!("storage_ptr = {storage_ptr}");
             if storage_ptr == 0 {
                 trie_data[storage_ptr_ptr] = Some(0.into());
             }
@@ -330,6 +499,7 @@ fn load_state_trie(
     }
 }
 
+#[cfg(not(feature = "cdk_erigon"))]
 fn get_state_and_storage_leaves(
     trie: &HashedPartialTrie,
     key: Nibbles,
@@ -340,6 +510,7 @@ fn get_state_and_storage_leaves(
     storage_pointers: &mut BTreeMap<(U256, U256), usize>,
     storage_tries_by_state_key: &HashMap<Nibbles, &HashedPartialTrie>,
 ) -> Result<(), ProgramError> {
+    log::debug!("lee su trie data len a {:?}", trie_data.len());
     match trie.deref() {
         Node::Branch { children, value } => {
             if !value.is_empty() {
@@ -384,8 +555,8 @@ fn get_state_and_storage_leaves(
             Ok(())
         }
         Node::Leaf { nibbles, value } => {
-            let account: AccountRlp = rlp::decode(value).map_err(|_| ProgramError::InvalidRlp)?;
-            let AccountRlp {
+            let account: MptAccount = rlp::decode(value).map_err(|_| ProgramError::InvalidRlp)?;
+            let MptAccount {
                 nonce,
                 balance,
                 storage_root,
@@ -415,13 +586,20 @@ fn get_state_and_storage_leaves(
             state_leaves.push(Some(addr_key));
             // Set `value_ptr_ptr`.
             state_leaves.push(Some(trie_data.len().into()));
-            // Set counter.
+            // Push something on the original `value_ptr_ptr` (to be set later in the
+            // kernel).
             state_leaves.push(Some(0.into()));
             // Set the next node as the initial node.
             state_leaves.push(Some((Segment::AccountsLinkedList as usize).into()));
 
             // Push the payload in the trie data.
             trie_data.push(Some(nonce));
+            log::debug!(
+                "key = {:?} nonce = {:?} balance= {:?}",
+                addr_key,
+                nonce,
+                balance
+            );
             trie_data.push(Some(balance));
             // The Storage pointer is only written in the trie.
             trie_data.push(Some(0.into()));
@@ -500,6 +678,8 @@ where
                 .try_into()
                 .map_err(|_| ProgramError::IntegerTooLarge)?;
             storage_leaves.push(Some(slot_key));
+
+            log::debug!("pushing keys {:?} and {:?}", addr_key, slot_key);
             // Write `value_ptr_ptr`.
             let leaves = parse_value(value)?
                 .into_iter()
@@ -527,48 +707,40 @@ where
 }
 
 /// A type alias used to gather:
-///     - the trie root pointers for all tries
 ///     - the vector of state trie leaves
 ///     - the vector of storage trie leaves
 ///     - the `TrieData` segment's memory content
-type TriePtrsLinkedLists = (
-    TrieRootPtrs,
-    Vec<Option<U256>>,
-    Vec<Option<U256>>,
-    Vec<Option<U256>>,
-);
-
-pub(crate) fn load_linked_lists_and_txn_and_receipt_mpts(
+type LinkedListsAndTrieData = (Vec<Option<U256>>, Vec<Option<U256>>, Vec<Option<U256>>);
+
+#[cfg(not(feature = "cdk_erigon"))]
+pub(crate) fn load_linked_lists(
     accounts_pointers: &mut BTreeMap<U256, usize>,
     storage_pointers: &mut BTreeMap<(U256, U256), usize>,
     trie_inputs: &TrieInputs,
-) -> Result<TriePtrsLinkedLists, ProgramError> {
+) -> Result<LinkedListsAndTrieData, ProgramError> {
     let mut state_leaves =
-        empty_list_mem::<ACCOUNTS_LINKED_LIST_NODE_SIZE>(Segment::AccountsLinkedList).to_vec();
+        empty_list_mem::<ACCOUNTS_LINKED_LIST_NODE_SIZE>(Segment::AccountsLinkedList as usize)
+            .to_vec();
     let mut storage_leaves =
-        empty_list_mem::<STORAGE_LINKED_LIST_NODE_SIZE>(Segment::StorageLinkedList).to_vec();
+        empty_list_mem::<STORAGE_LINKED_LIST_NODE_SIZE>(Segment::StorageLinkedList as usize)
+            .to_vec();
     let mut trie_data = vec![Some(U256::zero())];
-
-    let storage_tries_by_state_key = trie_inputs
-        .storage_tries
+    let mpt_state = match &trie_inputs.state_trie.state {
+        Either::Left(type1world) => type1world,
+        Either::Right(_) => unreachable!("eth_mainnet expects MPTs."),
+    };
+    let storage_tries_by_state_key = mpt_state
+        .get_storage()
         .iter()
         .map(|(hashed_address, storage_trie)| {
             let key = Nibbles::from_bytes_be(hashed_address.as_bytes())
                 .expect("An H256 is 32 bytes long");
-            (key, storage_trie)
+            (key, *storage_trie)
         })
         .collect();
 
-    let txn_root_ptr = load_mpt(&trie_inputs.transactions_trie, &mut trie_data, &|rlp| {
-        let mut parsed_txn = vec![U256::from(rlp.len())];
-        parsed_txn.extend(rlp.iter().copied().map(U256::from));
-        Ok(parsed_txn)
-    })?;
-
-    let receipt_root_ptr = load_mpt(&trie_inputs.receipts_trie, &mut trie_data, &parse_receipts)?;
-
     get_state_and_storage_leaves(
-        &trie_inputs.state_trie,
+        &mpt_state.state_trie(),
         empty_nibbles(),
         &mut state_leaves,
         &mut storage_leaves,
@@ -578,40 +750,59 @@ pub(crate) fn load_linked_lists_and_txn_and_receipt_mpts(
         &storage_tries_by_state_key,
     )?;
 
-    Ok((
-        TrieRootPtrs {
-            state_root_ptr: None,
-            txn_root_ptr,
-            receipt_root_ptr,
-        },
-        state_leaves,
-        storage_leaves,
-        trie_data,
-    ))
+    Ok((state_leaves, storage_leaves, trie_data))
 }
 
 pub(crate) fn load_state_mpt(
     trie_inputs: &TrimmedTrieInputs,
     trie_data: &mut Vec<Option<U256>>,
 ) -> Result<usize, ProgramError> {
-    let storage_tries_by_state_key = trie_inputs
-        .storage_tries
-        .iter()
-        .map(|(hashed_address, storage_trie)| {
-            let key = Nibbles::from_bytes_be(hashed_address.as_bytes())
-                .expect("An H256 is 32 bytes long");
-            (key, storage_trie)
-        })
-        .collect();
+    let storage_tries_by_state_key = match &trie_inputs.state_trie.state {
+        Either::Left(mpt) => {
+            log::debug!("el mundo = {:?}", mpt);
+            mpt.get_storage()
+                .iter()
+                .map(|(hashed_address, storage_trie)| {
+                    let key = Nibbles::from_bytes_be(hashed_address.as_bytes())
+                        .expect("An H256 is 32 bytes long");
+                    (key, *storage_trie)
+                })
+                .collect::<HashMap<_, _>>()
+        }
+        Either::Right(_) => unreachable!("eth_mainnet expects an MPT."),
+    };
+
+    let mpt_trie = match &trie_inputs.state_trie.state {
+        Either::Left(t) => t.state_trie(),
+        Either::Right(_) => unreachable!("eth_mainnet expects MPTs."),
+    };
 
     load_state_trie(
-        &trie_inputs.state_trie,
+        mpt_trie,
         empty_nibbles(),
         trie_data,
         &storage_tries_by_state_key,
     )
 }
 
+pub(crate) fn load_transactions_mpt(
+    transactions_trie: &HashedPartialTrie,
+    trie_data: &mut Vec<Option<U256>>,
+) -> Result<usize, ProgramError> {
+    load_mpt(transactions_trie, trie_data, &|rlp| {
+        let mut parsed_txn = vec![U256::from(rlp.len())];
+        parsed_txn.extend(rlp.iter().copied().map(U256::from));
+        Ok(parsed_txn)
+    })
+}
+
+pub(crate) fn load_receipts_mpt(
+    receipts_trie: &HashedPartialTrie,
+    trie_data: &mut Vec<Option<U256>>,
+) -> Result<usize, ProgramError> {
+    load_mpt(receipts_trie, trie_data, &parse_receipts)
+}
+
 pub mod transaction_testing {
     use ethereum_types::H160;
 
diff --git a/evm_arithmetization/src/generation/prover_input.rs b/evm_arithmetization/src/generation/prover_input.rs
index 704e2f4c6..c27b90dfc 100644
--- a/evm_arithmetization/src/generation/prover_input.rs
+++ b/evm_arithmetization/src/generation/prover_input.rs
@@ -4,7 +4,9 @@ use std::collections::{BTreeSet, HashMap};
 use std::str::FromStr;
 
 use anyhow::{bail, Error, Result};
-use ethereum_types::{BigEndianHash, H256, U256, U512};
+use either::Either;
+use ethereum_types::{BigEndianHash, H256};
+use ethereum_types::{U256, U512};
 use itertools::Itertools;
 use num_bigint::BigUint;
 use plonky2::hash::hash_types::RichField;
@@ -12,9 +14,9 @@ use serde::{Deserialize, Serialize};
 
 #[cfg(test)]
 use super::linked_list::testing::{LinkedList, ADDRESSES_ACCESS_LIST_LEN};
-use super::linked_list::{
-    LinkedListsPtrs, ACCOUNTS_LINKED_LIST_NODE_SIZE, DUMMYHEAD, STORAGE_LINKED_LIST_NODE_SIZE,
-};
+#[cfg(not(feature = "cdk_erigon"))]
+use super::linked_list::STORAGE_LINKED_LIST_NODE_SIZE;
+use super::linked_list::{AccessLinkedListsPtrs, ACCOUNTS_LINKED_LIST_NODE_SIZE, DUMMYHEAD};
 use super::mpt::load_state_mpt;
 use crate::cpu::kernel::cancun_constants::KZG_VERSIONED_HASH;
 use crate::cpu::kernel::constants::cancun_constants::{
@@ -99,7 +101,27 @@ impl<F: RichField> GenerationState<F> {
                     || {
                         let mut new_content = self.memory.get_preinit_memory(Segment::TrieData);
 
-                        let n = load_state_mpt(&self.inputs.trimmed_tries, &mut new_content)?;
+                        let n = if cfg!(feature = "cdk_erigon") {
+                            Ok(new_content.len())
+                        } else {
+                            load_state_mpt(&self.inputs.trimmed_tries, &mut new_content)
+                        };
+                        match &self.inputs.trimmed_tries.state_trie.state {
+                            Either::Left(_) => (),
+                            Either::Right(type2trie) => {
+                                let mut smt_data = type2trie
+                                    .as_smt()
+                                    .to_vec_skip_empty_node_and_add_offset(new_content.len());
+                                log::debug!("smt bef = {:?}", smt_data);
+                                if smt_data.len() == 2 {
+                                    smt_data.extend([U256::zero(); 2]);
+                                }
+                                log::debug!("initial smt = {:?}", smt_data);
+                                log::debug!("smt len = {:?}", smt_data.len());
+                                let smt_data = smt_data.into_iter().map(|x| Some(x));
+                                new_content.extend(smt_data);
+                            }
+                        };
 
                         self.memory.insert_preinitialized_segment(
                             Segment::TrieData,
@@ -107,7 +129,7 @@ impl<F: RichField> GenerationState<F> {
                                 content: new_content,
                             },
                         );
-                        Ok(n)
+                        n
                     },
                     Ok,
                 )
@@ -213,20 +235,35 @@ impl<F: RichField> GenerationState<F> {
     /// Returns the length of the code.
     fn run_account_code(&mut self) -> Result<U256, ProgramError> {
         // stack: codehash, ctx, ...
-        let codehash = stack_peek(self, 0)?;
+        let codehash = H256::from_uint(&stack_peek(self, 0)?);
         let context = stack_peek(self, 1)? >> CONTEXT_SCALING_FACTOR;
         let context = u256_to_usize(context)?;
         let mut address = MemoryAddress::new(context, Segment::Code, 0);
         let code = self
             .inputs
             .contract_code
-            .get(&H256::from_uint(&codehash))
+            .get(&codehash)
             .ok_or(ProgramError::ProverInputError(CodeHashNotFound))?;
+        let mut code_len = code.len();
+
         for &byte in code {
             self.memory.set(address, byte.into());
             address.increment();
         }
-        Ok(code.len().into())
+
+        #[cfg(feature = "cdk_erigon")]
+        {
+            // Padding
+            self.memory.set(address, 1.into());
+            code_len = code_len + 1;
+            code_len = 56 * ((code_len + 55) / 56);
+            let last_byte_addr = MemoryAddress::new(context, Segment::Code, code_len - 1);
+            let mut last_byte = u256_to_usize(self.memory.get_with_init(last_byte_addr))?;
+            last_byte |= 0x80;
+            self.memory.set(last_byte_addr, last_byte.into());
+        }
+
+        Ok(code_len.into())
     }
 
     // Bignum modular multiplication.
@@ -333,9 +370,11 @@ impl<F: RichField> GenerationState<F> {
 
     /// Generates either the next used jump address or the proof for the last
     /// jump address.
+    #[cfg(not(feature = "cdk_erigon"))]
     fn run_linked_list(&mut self, input_fn: &ProverInputFn) -> Result<U256, ProgramError> {
         match input_fn.0[1].as_str() {
             "insert_account" | "search_account" => self.run_next_insert_account(input_fn),
+
             "remove_account" => self.run_next_remove_account(),
             "insert_slot" | "search_slot" => self.run_next_insert_slot(input_fn),
             "remove_slot" => self.run_next_remove_slot(),
@@ -344,6 +383,34 @@ impl<F: RichField> GenerationState<F> {
         }
     }
 
+    /// Generates either the next used jump address or the proof for the last
+    /// jump address.
+    #[cfg(feature = "cdk_erigon")]
+    fn run_linked_list(&mut self, input_fn: &ProverInputFn) -> Result<U256, ProgramError> {
+        #[cfg(test)]
+        {
+            use crate::cpu::kernel::tests::mpt::linked_list::StateLinkedList;
+
+            let mem = self.memory.get_preinit_memory(Segment::AccountsLinkedList);
+
+            log::debug!(
+                "state ll = {:?}",
+                StateLinkedList::from_mem_and_segment(&mem, Segment::AccountsLinkedList)
+            );
+            log::debug!("state btree = {:#?}", self.inputs.trimmed_tries.state_trie);
+            log::debug!(
+                "input state popopo = {:?}",
+                self.inputs.trimmed_tries.state_trie.state
+            );
+        }
+
+        match input_fn.0[1].as_str() {
+            "insert_state" | "search_state" => self.run_next_insert_state(input_fn),
+            "remove_state" => self.run_next_remove_state(),
+            _ => Err(ProgramError::ProverInputError(InvalidInput)),
+        }
+    }
+
     fn run_global_exit_root(&mut self) -> Result<U256, ProgramError> {
         self.ger_prover_inputs
             .pop()
@@ -415,13 +482,13 @@ impl<F: RichField> GenerationState<F> {
 
         let (&pred_addr, &ptr) = self
             .access_lists_ptrs
-            .accounts
+            .accounts_pointers
             .range(..=addr)
             .next_back()
             .unwrap_or((&U256::MAX, &(Segment::AccessedAddresses as usize)));
 
         if pred_addr != addr {
-            self.access_lists_ptrs.accounts.insert(
+            self.access_lists_ptrs.accounts_pointers.insert(
                 addr,
                 u256_to_usize(
                     self.memory
@@ -440,12 +507,12 @@ impl<F: RichField> GenerationState<F> {
 
         let (_, &ptr) = self
             .access_lists_ptrs
-            .accounts
+            .accounts_pointers
             .range(..addr)
             .next_back()
             .unwrap_or((&U256::MAX, &(Segment::AccessedAddresses as usize)));
         self.access_lists_ptrs
-            .accounts
+            .accounts_pointers
             .remove(&addr)
             .ok_or(ProgramError::ProverInputError(InvalidInput))?;
 
@@ -460,12 +527,12 @@ impl<F: RichField> GenerationState<F> {
 
         let (&(pred_addr, pred_slot_key), &ptr) = self
             .access_lists_ptrs
-            .storage
+            .storage_pointers
             .range(..=(addr, key))
             .next_back()
             .unwrap_or((&DUMMYHEAD, &(Segment::AccessedStorageKeys as usize)));
         if pred_addr != addr || pred_slot_key != key {
-            self.access_lists_ptrs.storage.insert(
+            self.access_lists_ptrs.storage_pointers.insert(
                 (addr, key),
                 u256_to_usize(
                     self.memory
@@ -484,12 +551,12 @@ impl<F: RichField> GenerationState<F> {
 
         let (_, &ptr) = self
             .access_lists_ptrs
-            .storage
+            .storage_pointers
             .range(..(addr, key))
             .next_back()
             .unwrap_or((&DUMMYHEAD, &(Segment::AccessedStorageKeys as usize)));
         self.access_lists_ptrs
-            .storage
+            .storage_pointers
             .remove(&(addr, key))
             .ok_or(ProgramError::ProverInputError(InvalidInput))?;
 
@@ -497,24 +564,24 @@ impl<F: RichField> GenerationState<F> {
     }
 
     fn run_reset(&mut self) -> Result<U256, ProgramError> {
-        self.access_lists_ptrs = LinkedListsPtrs::default();
+        self.access_lists_ptrs = AccessLinkedListsPtrs::default();
         Ok(U256::zero())
     }
 
     /// Returns a pointer to a node in the list such that
     /// `node[0] <= addr < next_node[0]` and `addr` is the top of the stack.
+    #[cfg(not(feature = "cdk_erigon"))]
     fn run_next_insert_account(&mut self, input_fn: &ProverInputFn) -> Result<U256, ProgramError> {
         let addr = stack_peek(self, 0)?;
-
         let (&pred_addr, &pred_ptr) = self
-            .state_ptrs
-            .accounts
+            .state_pointers
+            .accounts_pointers
             .range(..=addr)
             .next_back()
             .unwrap_or((&U256::MAX, &(Segment::AccountsLinkedList as usize)));
 
         if pred_addr != addr && input_fn.0[1].as_str() == "insert_account" {
-            self.state_ptrs.accounts.insert(
+            self.state_pointers.accounts_pointers.insert(
                 addr,
                 u256_to_usize(
                     self.memory
@@ -522,7 +589,30 @@ impl<F: RichField> GenerationState<F> {
                 )?,
             );
         }
+        Ok(U256::from(pred_ptr / ACCOUNTS_LINKED_LIST_NODE_SIZE))
+    }
+
+    /// Returns a pointer to a node in the list such that
+    /// `node[0] <= key < next_node[0]` and `key` is the top of the stack.
+    #[cfg(feature = "cdk_erigon")]
+    fn run_next_insert_state(&mut self, input_fn: &ProverInputFn) -> Result<U256, ProgramError> {
+        let key = stack_peek(self, 0)?;
+        let (&pred_key, &pred_ptr) = self
+            .state_pointers
+            .state
+            .range(..=key)
+            .next_back()
+            .unwrap_or((&U256::MAX, &(Segment::AccountsLinkedList as usize)));
 
+        if pred_key != key && input_fn.0[1].as_str() == "insert_state" {
+            self.state_pointers.state.insert(
+                key,
+                u256_to_usize(
+                    self.memory
+                        .read_global_metadata(GlobalMetadata::AccountsLinkedListNextAvailable),
+                )?,
+            );
+        }
         Ok(U256::from(pred_ptr / ACCOUNTS_LINKED_LIST_NODE_SIZE))
     }
 
@@ -530,18 +620,19 @@ impl<F: RichField> GenerationState<F> {
     /// `node[0] <= addr < next_node[0]`, or  node[0] == addr and `node[1] <=
     /// key < next_node[1]`, where `addr` and `key` are the elements at the top
     /// of the stack.
+    #[cfg(not(feature = "cdk_erigon"))]
     fn run_next_insert_slot(&mut self, input_fn: &ProverInputFn) -> Result<U256, ProgramError> {
         let addr = stack_peek(self, 0)?;
         let key = stack_peek(self, 1)?;
 
         let (&(pred_addr, pred_slot_key), &pred_ptr) = self
-            .state_ptrs
-            .storage
+            .state_pointers
+            .storage_pointers
             .range(..=(addr, key))
             .next_back()
             .unwrap_or((&DUMMYHEAD, &(Segment::StorageLinkedList as usize)));
         if (pred_addr != addr || pred_slot_key != key) && input_fn.0[1] == "insert_slot" {
-            self.state_ptrs.storage.insert(
+            self.state_pointers.storage_pointers.insert(
                 (addr, key),
                 u256_to_usize(
                     self.memory
@@ -555,41 +646,66 @@ impl<F: RichField> GenerationState<F> {
     }
 
     /// Returns a pointer `ptr` to a node of the form [..] -> [next_addr, ..]
-    /// list such that `next_addr = addr` and `addr` is the top of the stack.
-    /// If the element is not in the list, loops forever.
+    /// such that `next_addr = addr` and `addr` is the top of the stack.
+    /// If the element is not in the list, returns an error.
+    #[cfg(not(feature = "cdk_erigon"))]
     fn run_next_remove_account(&mut self) -> Result<U256, ProgramError> {
         let addr = stack_peek(self, 0)?;
 
         let (_, &ptr) = self
-            .state_ptrs
-            .accounts
+            .state_pointers
+            .accounts_pointers
             .range(..addr)
             .next_back()
             .unwrap_or((&U256::MAX, &(Segment::AccountsLinkedList as usize)));
-        self.state_ptrs
-            .accounts
+        self.state_pointers
+            .accounts_pointers
             .remove(&addr)
             .ok_or(ProgramError::ProverInputError(InvalidInput))?;
 
         Ok(U256::from(ptr / ACCOUNTS_LINKED_LIST_NODE_SIZE))
     }
 
+    /// Returns a pointer `ptr` to a node of the form [..] -> [next_key, ..]
+    /// such that `next_key = addr` and `key` is the top of the stack.
+    /// If the element is not in the list, returns an error.
+    #[cfg(feature = "cdk_erigon")]
+    fn run_next_remove_state(&mut self) -> Result<U256, ProgramError> {
+        let addr = stack_peek(self, 0)?;
+
+        log::debug!(
+            "los que viene antes: = {:?}",
+            self.state_pointers.state.range(..addr).next_back()
+        );
+
+        let (_, &ptr) = self
+            .state_pointers
+            .state
+            .range(..addr)
+            .next_back()
+            .unwrap_or((&U256::MAX, &(Segment::AccountsLinkedList as usize)));
+        self.state_pointers.state.remove(&addr);
+
+        Ok(U256::from(ptr / ACCOUNTS_LINKED_LIST_NODE_SIZE))
+    }
+
     /// Returns a pointer `ptr` to a node = `[next_addr, next_key]` in the list
     /// such that `next_addr == addr` and `next_key == key`,
     /// and `addr, key` are the elements at the top of the stack.
     /// If the element is not in the list, loops forever.
+    #[cfg(not(feature = "cdk_erigon"))]
     fn run_next_remove_slot(&mut self) -> Result<U256, ProgramError> {
         let addr = stack_peek(self, 0)?;
         let key = stack_peek(self, 1)?;
 
         let (_, &ptr) = self
-            .state_ptrs
-            .storage
+            .state_pointers
+            .storage_pointers
             .range(..(addr, key))
             .next_back()
             .unwrap_or((&DUMMYHEAD, &(Segment::StorageLinkedList as usize)));
-        self.state_ptrs
-            .storage
+        self.state_pointers
+            .storage_pointers
             .remove(&(addr, key))
             .ok_or(ProgramError::ProverInputError(InvalidInput))?;
 
@@ -602,12 +718,13 @@ impl<F: RichField> GenerationState<F> {
     /// `next_addr = @U256_MAX`. This is used to determine the first storage
     /// node for the account at `addr`. `addr` is the element at the top of the
     /// stack.
+    #[cfg(not(feature = "cdk_erigon"))]
     fn run_next_remove_address_slots(&mut self) -> Result<U256, ProgramError> {
         let addr = stack_peek(self, 0)?;
 
         let (_, &pred_ptr) = self
-            .state_ptrs
-            .storage
+            .state_pointers
+            .storage_pointers
             .range(..(addr, U256::zero()))
             .next_back()
             .unwrap_or((&DUMMYHEAD, &(Segment::StorageLinkedList as usize)));
@@ -616,6 +733,8 @@ impl<F: RichField> GenerationState<F> {
             (pred_ptr - Segment::StorageLinkedList as usize) / STORAGE_LINKED_LIST_NODE_SIZE,
         ))
     }
+    // TODO: We're missing a cdk_erigon counterpart for
+    // `run_next_remove_address_slots`
 
     #[cfg(test)]
     pub(crate) fn get_addresses_access_list(
@@ -815,7 +934,7 @@ impl<F: RichField> GenerationState<F> {
         self.get_code(self.registers.context)
     }
 
-    fn get_code(&self, context: usize) -> Result<Vec<u8>, ProgramError> {
+    pub(crate) fn get_code(&self, context: usize) -> Result<Vec<u8>, ProgramError> {
         let code_len = self.get_code_len(context)?;
         let code = (0..code_len)
             .map(|i| {
@@ -828,7 +947,7 @@ impl<F: RichField> GenerationState<F> {
         Ok(code)
     }
 
-    fn get_code_len(&self, context: usize) -> Result<usize, ProgramError> {
+    pub fn get_code_len(&self, context: usize) -> Result<usize, ProgramError> {
         let code_len = u256_to_usize(self.memory.get_with_init(MemoryAddress::new(
             context,
             Segment::ContextMetadata,
diff --git a/evm_arithmetization/src/generation/segments.rs b/evm_arithmetization/src/generation/segments.rs
index 1df63af29..e60afce20 100644
--- a/evm_arithmetization/src/generation/segments.rs
+++ b/evm_arithmetization/src/generation/segments.rs
@@ -83,8 +83,8 @@ fn build_segment_data<F: RichField>(
             trie_root_ptrs: interpreter.generation_state.trie_root_ptrs.clone(),
             jumpdest_table: interpreter.generation_state.jumpdest_table.clone(),
             next_txn_index: interpreter.generation_state.next_txn_index,
+            state_ptrs: interpreter.generation_state.state_pointers.clone(),
             access_lists_ptrs: interpreter.generation_state.access_lists_ptrs.clone(),
-            state_ptrs: interpreter.generation_state.state_ptrs.clone(),
         },
         #[cfg(test)]
         opcode_counts: interpreter.opcode_count.clone(),
diff --git a/evm_arithmetization/src/generation/state.rs b/evm_arithmetization/src/generation/state.rs
index abe4b4f1a..36c4e3d6c 100644
--- a/evm_arithmetization/src/generation/state.rs
+++ b/evm_arithmetization/src/generation/state.rs
@@ -1,4 +1,4 @@
-use std::collections::HashMap;
+use std::collections::{BTreeMap, HashMap};
 use std::mem::size_of;
 
 use anyhow::{anyhow, bail};
@@ -7,8 +7,8 @@ use itertools::Itertools;
 use keccak_hash::keccak;
 use log::Level;
 use plonky2::hash::hash_types::RichField;
+use smt_trie::code::hash_bytecode_h256;
 
-use super::linked_list::LinkedListsPtrs;
 use super::mpt::TrieRootPtrs;
 use super::segments::GenerationSegmentData;
 use super::{TrieInputs, TrimmedGenerationInputs, NUM_EXTRA_CYCLES_AFTER};
@@ -16,7 +16,12 @@ use crate::byte_packing::byte_packing_stark::BytePackingOp;
 use crate::cpu::kernel::aggregator::KERNEL;
 use crate::cpu::kernel::constants::context_metadata::ContextMetadata;
 use crate::cpu::stack::MAX_USER_STACK_SIZE;
-use crate::generation::mpt::load_linked_lists_and_txn_and_receipt_mpts;
+#[cfg(feature = "cdk_erigon")]
+use crate::generation::linked_list::{empty_list_mem, STATE_LINKED_LIST_NODE_SIZE};
+use crate::generation::linked_list::{AccessLinkedListsPtrs, StateLinkedListsPtrs};
+#[cfg(not(feature = "cdk_erigon"))]
+use crate::generation::mpt::load_linked_lists;
+use crate::generation::mpt::{load_receipts_mpt, load_transactions_mpt};
 use crate::generation::rlp::all_rlp_prover_inputs_reversed;
 use crate::generation::CpuColumnsView;
 use crate::generation::GenerationInputs;
@@ -204,6 +209,31 @@ pub(crate) trait State<F: RichField> {
         let mut running = true;
         let mut final_clock = 0;
 
+        #[cfg(test)]
+        {
+            let mem = self
+                .get_generation_state()
+                .memory
+                .get_preinit_memory(Segment::AccountsLinkedList);
+            use crate::cpu::kernel::tests::mpt::linked_list::StateLinkedList;
+            log::debug!(
+                "initial state linked list = {:?}",
+                StateLinkedList::from_mem_and_segment(&mem, Segment::AccountsLinkedList)
+            );
+            #[cfg(not(feature = "cdk_erigon"))]
+            {
+                use crate::cpu::kernel::tests::mpt::linked_list::StorageLinkedList;
+                let mem = self
+                    .get_generation_state()
+                    .memory
+                    .get_preinit_memory(Segment::StorageLinkedList);
+                log::debug!(
+                    "initial storage linked list = {:?}",
+                    StorageLinkedList::from_mem_and_segment(&mem, Segment::StorageLinkedList)
+                );
+            }
+        }
+
         loop {
             let registers = self.get_registers();
             let pc = registers.program_counter;
@@ -243,7 +273,6 @@ pub(crate) trait State<F: RichField> {
                     return Ok((final_registers, final_mem));
                 }
             }
-
             self.transition()?;
         }
     }
@@ -262,13 +291,11 @@ pub(crate) trait State<F: RichField> {
             ProgramError::StackOverflow => 5,
             _ => bail!("TODO: figure out what to do with this..."),
         };
-
         let checkpoint = self.checkpoint();
 
         let (row, _) = self.base_row();
         generate_exception(exc_code, self, row)
             .map_err(|e| anyhow!("Exception handling failed with error: {:?}", e))?;
-
         self.apply_ops(checkpoint);
 
         Ok(())
@@ -289,7 +316,6 @@ pub(crate) trait State<F: RichField> {
                 if might_overflow_op(op) {
                     self.get_mut_registers().check_overflow = true;
                 }
-
                 Ok(())
             }
             Err(e) => {
@@ -389,28 +415,55 @@ pub struct GenerationState<F: RichField> {
     pub(crate) jumpdest_table: Option<HashMap<usize, Vec<usize>>>,
 
     /// Provides quick access to pointers that reference the location
-    /// of either and account or a slot in the respective access list.
-    pub(crate) access_lists_ptrs: LinkedListsPtrs,
+    /// of either an account or a slot in the respective access list.
+    pub(crate) access_lists_ptrs: AccessLinkedListsPtrs,
 
-    /// Provides quick access to pointers that reference the memory location of
-    /// either and account or a slot in the respective access list.
-    pub(crate) state_ptrs: LinkedListsPtrs,
+    /// Provides quick access to pointers that reference the location
+    /// of either an account or a slot in the respective linked list.
+    pub(crate) state_pointers: StateLinkedListsPtrs,
 }
 
 impl<F: RichField> GenerationState<F> {
-    fn preinitialize_linked_lists_and_txn_and_receipt_mpts(
+    pub(crate) fn preinitialize_trie_data_and_get_trie_ptrs(
         &mut self,
         trie_inputs: &TrieInputs,
     ) -> TrieRootPtrs {
+        self.preinitialize_linked_lists(trie_inputs);
+
+        let mut trie_data = self.memory.get_preinit_memory(Segment::TrieData);
+
+        log::debug!("trie data len after ll {:?}", trie_data.len());
+
+        let txn_root_ptr =
+            load_transactions_mpt(&trie_inputs.transactions_trie, &mut trie_data).unwrap();
+
+        log::debug!("trie data len after txn {:?}", trie_data.len());
+        let receipt_root_ptr =
+            load_receipts_mpt(&trie_inputs.receipts_trie, &mut trie_data).unwrap();
+
+        log::debug!("trie data len after receipts {:?}", trie_data.len());
+        self.memory.insert_preinitialized_segment(
+            Segment::TrieData,
+            crate::witness::memory::MemorySegmentState { content: trie_data },
+        );
+        TrieRootPtrs {
+            state_root_ptr: None,
+            txn_root_ptr,
+            receipt_root_ptr,
+        }
+    }
+
+    #[cfg(not(feature = "cdk_erigon"))]
+    fn preinitialize_linked_lists(&mut self, trie_inputs: &TrieInputs) {
         let generation_state = self.get_mut_generation_state();
-        let (trie_roots_ptrs, state_leaves, storage_leaves, trie_data) =
-            load_linked_lists_and_txn_and_receipt_mpts(
-                &mut generation_state.state_ptrs.accounts,
-                &mut generation_state.state_ptrs.storage,
+        let (state_leaves, storage_leaves, trie_data) =
+            load_linked_lists(
+                &mut generation_state.state_pointers.accounts_pointers,
+                &mut generation_state.state_pointers.storage_pointers,
                 trie_inputs,
             )
             .expect("Invalid MPT data for preinitialization");
-
+        log::debug!("accounts segment length {}", state_leaves.len());
         self.memory.insert_preinitialized_segment(
             Segment::AccountsLinkedList,
             crate::witness::memory::MemorySegmentState {
@@ -427,8 +480,36 @@ impl<F: RichField> GenerationState<F> {
             Segment::TrieData,
             crate::witness::memory::MemorySegmentState { content: trie_data },
         );
+    }
+
+    #[cfg(feature = "cdk_erigon")]
+    pub(crate) fn preinitialize_linked_lists(&mut self, trie_inputs: &TrieInputs) {
+        let generation_state = self.get_mut_generation_state();
+        let mut smt_data = vec![Some(U256::zero()); 2]; // For empty hash node.
+        let mut state_linked_list_data =
+            empty_list_mem::<STATE_LINKED_LIST_NODE_SIZE>(Segment::AccountsLinkedList as usize)
+                .to_vec();
+        trie_inputs
+            .state_trie
+            .state
+            .clone()
+            .expect_right("cdk_erigon requires SMTs.")
+            .as_smt()
+            .load_linked_list_data::<{ Segment::AccountsLinkedList as usize }>(
+                &mut state_linked_list_data,
+                &mut self.state_pointers.state,
+            );
 
-        trie_roots_ptrs
+        self.memory.insert_preinitialized_segment(
+            Segment::AccountsLinkedList,
+            crate::witness::memory::MemorySegmentState {
+                content: state_linked_list_data,
+            },
+        );
+        self.memory.insert_preinitialized_segment(
+            Segment::TrieData,
+            crate::witness::memory::MemorySegmentState { content: smt_data },
+        );
     }
 
     pub(crate) fn new(
@@ -439,33 +520,70 @@ impl<F: RichField> GenerationState<F> {
         let withdrawal_prover_inputs = all_withdrawals_prover_inputs_reversed(&inputs.withdrawals);
         let ger_prover_inputs = all_ger_prover_inputs(inputs.ger_data);
         let bignum_modmul_result_limbs = Vec::new();
-
-        let mut state = Self {
-            inputs: inputs.trim(),
-            registers: Default::default(),
-            memory: MemoryState::new(kernel_code),
-            traces: Traces::default(),
-            next_txn_index: 0,
-            stale_contexts: Vec::new(),
-            rlp_prover_inputs,
-            withdrawal_prover_inputs,
-            state_key_to_address: HashMap::new(),
-            bignum_modmul_result_limbs,
-            trie_root_ptrs: TrieRootPtrs {
-                state_root_ptr: Some(0),
-                txn_root_ptr: 0,
-                receipt_root_ptr: 0,
-            },
-            jumpdest_table: None,
-            access_lists_ptrs: LinkedListsPtrs::default(),
-            state_ptrs: LinkedListsPtrs::default(),
-            ger_prover_inputs,
-        };
-        let trie_root_ptrs =
-            state.preinitialize_linked_lists_and_txn_and_receipt_mpts(&inputs.tries);
-
-        state.trie_root_ptrs = trie_root_ptrs;
-        Ok(state)
+        log::debug!("smt trie = {:?}", inputs.tries.state_trie);
+
+        #[cfg(not(feature = "cdk_erigon"))]
+        {
+            let mut state = Self {
+                inputs: inputs.trim(),
+                registers: Default::default(),
+                memory: MemoryState::new(kernel_code),
+                traces: Traces::default(),
+                next_txn_index: 0,
+                stale_contexts: Vec::new(),
+                rlp_prover_inputs,
+                withdrawal_prover_inputs,
+                state_key_to_address: HashMap::new(),
+                bignum_modmul_result_limbs,
+                trie_root_ptrs: TrieRootPtrs {
+                    state_root_ptr: Some(0),
+                    txn_root_ptr: 0,
+                    receipt_root_ptr: 0,
+                },
+                jumpdest_table: None,
+                access_lists_ptrs: AccessLinkedListsPtrs::default(),
+                state_pointers: StateLinkedListsPtrs {
+                    accounts_pointers: BTreeMap::new(),
+                    storage_pointers: BTreeMap::new(),
+                },
+                ger_prover_inputs,
+            };
+            log::debug!("gen state");
+            let trie_root_ptrs = state.preinitialize_trie_data_and_get_trie_ptrs(&inputs.tries);
+
+            state.trie_root_ptrs = trie_root_ptrs;
+            Ok(state)
+        }
+        #[cfg(feature = "cdk_erigon")]
+        {
+            let mut state = Self {
+                inputs: inputs.trim(),
+                registers: Default::default(),
+                memory: MemoryState::new(kernel_code),
+                traces: Traces::default(),
+                next_txn_index: 0,
+                stale_contexts: Vec::new(),
+                rlp_prover_inputs,
+                withdrawal_prover_inputs,
+                state_key_to_address: HashMap::new(),
+                bignum_modmul_result_limbs,
+                trie_root_ptrs: TrieRootPtrs {
+                    state_root_ptr: Some(0),
+                    txn_root_ptr: 0,
+                    receipt_root_ptr: 0,
+                },
+                jumpdest_table: None,
+                access_lists_ptrs: AccessLinkedListsPtrs::default(),
+                state_pointers: StateLinkedListsPtrs {
+                    state: BTreeMap::new(),
+                },
+                ger_prover_inputs,
+            };
+            let trie_root_ptrs = state.preinitialize_trie_data_and_get_trie_ptrs(&inputs.tries);
+
+            state.trie_root_ptrs = trie_root_ptrs;
+            Ok(state)
+        }
     }
 
     pub(crate) fn new_with_segment_data(
@@ -474,8 +592,6 @@ impl<F: RichField> GenerationState<F> {
     ) -> Result<Self, ProgramError> {
         let mut state = Self {
             inputs: trimmed_inputs.clone(),
-            state_ptrs: segment_data.extra_data.state_ptrs.clone(),
-            access_lists_ptrs: segment_data.extra_data.access_lists_ptrs.clone(),
             ..Default::default()
         };
 
@@ -501,8 +617,8 @@ impl<F: RichField> GenerationState<F> {
             self.observe_address(tip_h160);
         } else if dst == KERNEL.global_labels["observe_new_contract"] {
             let tip_u256 = stack_peek(self, 0)?;
-            let tip_h256 = H256::from_uint(&tip_u256);
-            self.observe_contract(tip_h256)?;
+            let tip = H256::from_uint(&tip_u256);
+            self.observe_contract(tip)?;
         }
 
         Ok(())
@@ -534,7 +650,12 @@ impl<F: RichField> GenerationState<F> {
             .iter()
             .map(|x| x.unwrap_or_default().low_u32() as u8)
             .collect::<Vec<_>>();
-        debug_assert_eq!(keccak(&code), codehash);
+        let hash = if cfg!(feature = "cdk_erigon") {
+            keccak(&code)
+        } else {
+            hash_bytecode_h256(&code)
+        };
+        debug_assert_eq!(hash, codehash);
 
         self.inputs.contract_code.insert(codehash, code);
 
@@ -574,7 +695,7 @@ impl<F: RichField> GenerationState<F> {
             },
             jumpdest_table: None,
             access_lists_ptrs: self.access_lists_ptrs.clone(),
-            state_ptrs: self.state_ptrs.clone(),
+            state_pointers: self.state_pointers.clone(),
         }
     }
 
@@ -591,7 +712,7 @@ impl<F: RichField> GenerationState<F> {
             .clone_from(&segment_data.extra_data.trie_root_ptrs);
         self.jumpdest_table
             .clone_from(&segment_data.extra_data.jumpdest_table);
-        self.state_ptrs
+        self.state_pointers
             .clone_from(&segment_data.extra_data.state_ptrs);
         self.access_lists_ptrs
             .clone_from(&segment_data.extra_data.access_lists_ptrs);
diff --git a/evm_arithmetization/src/generation/trie_extractor.rs b/evm_arithmetization/src/generation/trie_extractor.rs
index 48fc28f53..e292fc38e 100644
--- a/evm_arithmetization/src/generation/trie_extractor.rs
+++ b/evm_arithmetization/src/generation/trie_extractor.rs
@@ -5,7 +5,7 @@ use ethereum_types::{BigEndianHash, H256, U256};
 use mpt_trie::nibbles::{Nibbles, NibblesIntern};
 use mpt_trie::partial_trie::{HashedPartialTrie, Node, PartialTrie, WrappedNode};
 
-use super::mpt::{AccountRlp, LegacyReceiptRlp, LogRlp};
+use super::mpt::{LegacyReceiptRlp, LogRlp};
 use crate::cpu::kernel::constants::trie_type::PartialTrieType;
 use crate::memory::segments::Segment;
 use crate::util::{u256_to_bool, u256_to_h160, u256_to_u8, u256_to_usize};
@@ -89,15 +89,18 @@ pub(crate) fn read_logs(
         .collect()
 }
 
+#[cfg(not(feature = "cdk_erigon"))]
 pub(crate) fn read_state_rlp_value(
     memory: &MemoryState,
     slice: &MemoryValues,
 ) -> Result<Vec<u8>, ProgramError> {
+    use super::mpt::MptAccount;
+
     let storage_trie: HashedPartialTrie =
         get_trie(memory, slice[2].unwrap_or_default().as_usize(), |_, x| {
             Ok(rlp::encode(&read_storage_trie_value(x)).to_vec())
         })?;
-    let account = AccountRlp {
+    let account = MptAccount {
         nonce: slice[0].unwrap_or_default(),
         balance: slice[1].unwrap_or_default(),
         storage_root: storage_trie.hash(),
@@ -130,6 +133,7 @@ pub(crate) fn read_receipt_rlp_value(
     Ok(bytes)
 }
 
+#[cfg(not(feature = "cdk_erigon"))]
 pub(crate) fn get_state_trie<N: PartialTrie>(
     memory: &MemoryState,
     ptr: usize,
diff --git a/evm_arithmetization/src/memory/segments.rs b/evm_arithmetization/src/memory/segments.rs
index a9534830a..4b823cd1b 100644
--- a/evm_arithmetization/src/memory/segments.rs
+++ b/evm_arithmetization/src/memory/segments.rs
@@ -86,6 +86,8 @@ pub(crate) enum Segment {
     CreatedContracts = 37 << SEGMENT_SCALING_FACTOR,
     /// Blob versioned hashes specified in a type-3 transaction.
     TxnBlobVersionedHashes = 38 << SEGMENT_SCALING_FACTOR,
+    /// List of used storage slots in newly created contracts.
+    NewStorageSlots = 39 << SEGMENT_SCALING_FACTOR,
 }
 
 // These segments are not zero-initialized.
@@ -97,7 +99,7 @@ pub(crate) const PREINITIALIZED_SEGMENTS_INDICES: [usize; 4] = [
 ];
 
 impl Segment {
-    pub(crate) const COUNT: usize = 39;
+    pub(crate) const COUNT: usize = 40;
 
     /// Unscales this segment by `SEGMENT_SCALING_FACTOR`.
     #[inline(always)]
@@ -147,6 +149,7 @@ impl Segment {
             Self::TransientStorage,
             Self::CreatedContracts,
             Self::TxnBlobVersionedHashes,
+            Self::NewStorageSlots,
         ]
     }
 
@@ -192,6 +195,7 @@ impl Segment {
             Segment::TransientStorage => "SEGMENT_TRANSIENT_STORAGE",
             Segment::CreatedContracts => "SEGMENT_CREATED_CONTRACTS",
             Segment::TxnBlobVersionedHashes => "SEGMENT_TXN_BLOB_VERSIONED_HASHES",
+            Segment::NewStorageSlots => "SEGMENT_NEW_STORAGE_SLOTS",
         }
     }
 
@@ -236,6 +240,7 @@ impl Segment {
             Segment::TransientStorage => 256,
             Segment::CreatedContracts => 256,
             Segment::TxnBlobVersionedHashes => 256,
+            Segment::NewStorageSlots => 256,
         }
     }
 }
diff --git a/evm_arithmetization/src/testing_utils.rs b/evm_arithmetization/src/testing_utils.rs
index ac3cdcf0f..c4573d70b 100644
--- a/evm_arithmetization/src/testing_utils.rs
+++ b/evm_arithmetization/src/testing_utils.rs
@@ -14,17 +14,22 @@ use plonky2::field::goldilocks_field::GoldilocksField;
 use plonky2::fri::reduction_strategies::FriReductionStrategy;
 use plonky2::fri::FriConfig;
 use plonky2::plonk::circuit_data::CircuitConfig;
+#[cfg(feature = "cdk_erigon")]
+use smt_trie::smt::Smt;
 use starky::config::StarkConfig;
 
 pub use crate::cpu::kernel::cancun_constants::*;
 pub use crate::cpu::kernel::constants::global_exit_root::*;
-use crate::generation::{TrieInputs, TrimmedGenerationInputs};
+use crate::generation::mpt::MptAccount;
 use crate::proof::TrieRoots;
 #[cfg(test)]
 use crate::witness::operation::Operation;
 use crate::{
-    generation::mpt::AccountRlp, proof::BlockMetadata, util::h2u, GenerationInputs,
-    GenerationSegmentData, SegmentDataIterator,
+    generation::{TrieInputs, TrimmedGenerationInputs},
+    world::StateWorld,
+};
+use crate::{
+    proof::BlockMetadata, util::h2u, GenerationInputs, GenerationSegmentData, SegmentDataIterator,
 };
 
 pub const EMPTY_NODE_HASH: H256 = H256(hex!(
@@ -88,6 +93,7 @@ fn insert_storage(trie: &mut HashedPartialTrie, slot: U256, value: U256) -> anyh
     let mut bytes = [0; 32];
     slot.to_big_endian(&mut bytes);
     let key = keccak(bytes);
+    log::debug!("slot key = {:?}", key);
     let nibbles = Nibbles::from_bytes_be(key.as_bytes()).unwrap();
     if value.is_zero() {
         trie.delete(nibbles)?;
@@ -118,13 +124,26 @@ pub fn update_beacon_roots_account_storage(
     let timestamp_idx = timestamp % HISTORY_BUFFER_LENGTH.value;
     let root_idx = timestamp_idx + HISTORY_BUFFER_LENGTH.value;
 
+    log::debug!(
+        "inseting timestamp = {:?} and root = {:?}",
+        timestamp,
+        h2u(parent_root)
+    );
+    log::debug!("initial storage trie = {:?}", storage_trie);
+
     insert_storage(storage_trie, timestamp_idx, timestamp)?;
-    insert_storage(storage_trie, root_idx, h2u(parent_root))
+    insert_storage(storage_trie, root_idx, h2u(parent_root))?;
+
+    log::debug!("storage trie = {:?}", storage_trie);
+
+    Ok(())
 }
 
 /// Returns the beacon roots contract account from its provided storage trie.
-pub fn beacon_roots_contract_from_storage(storage_trie: &HashedPartialTrie) -> AccountRlp {
-    AccountRlp {
+#[cfg(feature = "eth_mainnet")]
+pub fn beacon_roots_contract_from_storage(storage_trie: &HashedPartialTrie) -> MptAccount {
+    log::debug!("hashing beacon roots");
+    MptAccount {
         storage_root: storage_trie.hash(),
         ..BEACON_ROOTS_ACCOUNT
     }
@@ -132,6 +151,7 @@ pub fn beacon_roots_contract_from_storage(storage_trie: &HashedPartialTrie) -> A
 
 /// Returns an initial state trie containing the beacon roots and global exit
 /// roots contracts, along with their storage tries.
+#[cfg(feature = "eth_mainnet")]
 pub fn preinitialized_state_and_storage_tries(
 ) -> anyhow::Result<(HashedPartialTrie, Vec<(H256, HashedPartialTrie)>)> {
     let mut state_trie = HashedPartialTrie::from(Node::Empty);
@@ -199,15 +219,17 @@ pub fn update_scalable_account_storage(
     insert_storage(storage_trie, slot.into_uint(), h2u(initial_trie_hash))
 }
 
-pub fn ger_contract_from_storage(storage_trie: &HashedPartialTrie) -> AccountRlp {
-    AccountRlp {
+#[cfg(feature = "cdk_erigon")]
+pub fn ger_contract_from_storage(storage_trie: &HashedPartialTrie) -> MptAccount {
+    MptAccount {
         storage_root: storage_trie.hash(),
         ..GLOBAL_EXIT_ROOT_ACCOUNT
     }
 }
 
-pub fn scalable_contract_from_storage(storage_trie: &HashedPartialTrie) -> AccountRlp {
-    AccountRlp {
+#[cfg(feature = "cdk_erigon")]
+pub fn scalable_contract_from_storage(storage_trie: &HashedPartialTrie) -> MptAccount {
+    MptAccount {
         storage_root: storage_trie.hash(),
         ..Default::default()
     }
@@ -229,13 +251,12 @@ fn empty_payload() -> Result<GenerationInputs> {
 
     // Initialize an empty state trie and storage tries
     let state_trie_before = HashedPartialTrie::from(crate::Node::Empty);
-    let storage_tries = Vec::new();
+
     let checkpoint_state_trie_root = state_trie_before.hash();
 
     // Prepare the tries without any transactions or receipts
     let tries_before = TrieInputs {
-        state_trie: state_trie_before.clone(),
-        storage_tries: storage_tries.clone(),
+        state_trie: StateWorld::default(),
         transactions_trie: HashedPartialTrie::from(crate::Node::Empty),
         receipts_trie: HashedPartialTrie::from(crate::Node::Empty),
     };
@@ -275,6 +296,34 @@ pub fn segment_with_empty_tables() -> Result<(
     Ok((trimmed_inputs, segment_data))
 }
 
+#[cfg(not(feature = "cdk_erigon"))]
+pub fn get_state_world(
+    state: HashedPartialTrie,
+    storage_tries: Vec<(H256, HashedPartialTrie)>,
+) -> StateWorld {
+    use std::collections::BTreeMap;
+
+    use either::Either;
+    // `Type1World` expects full keys, so we manually expand the nibbles here.
+    use mpt_trie::utils::TryFromIterator as _;
+
+    use crate::{
+        tries::{StateMpt, StorageTrie},
+        world::Type1World,
+    };
+
+    let mut type1world =
+        Type1World::new(StateMpt::new_with_inner(state), BTreeMap::default()).unwrap();
+    let mut init_storage = BTreeMap::default();
+    for (storage, v) in storage_tries {
+        init_storage.insert(storage, StorageTrie::new_with_trie(v));
+    }
+    type1world.set_storage(init_storage);
+    StateWorld {
+        state: Either::Left(type1world),
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
diff --git a/evm_arithmetization/src/tries.rs b/evm_arithmetization/src/tries.rs
index 61531a1ef..5b1dc1a29 100644
--- a/evm_arithmetization/src/tries.rs
+++ b/evm_arithmetization/src/tries.rs
@@ -8,9 +8,10 @@ use bitvec::{array::BitArray, slice::BitSlice};
 use copyvec::CopyVec;
 use ethereum_types::{Address, H256, U256};
 use mpt_trie::partial_trie::{HashedPartialTrie, Node, OnOrphanedHashNode, PartialTrie as _};
+use serde::{Deserialize, Serialize};
 use u4::{AsNibbles, U4};
 
-use crate::generation::mpt::AccountRlp;
+use crate::generation::mpt::MptAccount;
 
 /// Bounded sequence of [`U4`],
 /// used as a key for [MPT](HashedPartialTrie) types in this module.
@@ -97,7 +98,7 @@ fn mpt_key_into_hash() {
 /// used as a key for SMT tries.
 ///
 /// Semantically equivalent to [`smt_trie::bits::Bits`].
-#[derive(Clone, Copy)]
+#[derive(Clone, Copy, Serialize, Deserialize)]
 pub struct SmtKey {
     bits: bitvec::array::BitArray<[u8; 32]>,
     len: usize,
@@ -271,12 +272,12 @@ impl From<ReceiptTrie> for HashedPartialTrie {
     }
 }
 
-/// Global, [`Address`] `->` [`AccountRlp`].
+/// Global, [`Address`] `->` [`Account`].
 ///
 /// See <https://ethereum.org/en/developers/docs/data-structures-and-encoding/patricia-merkle-trie/#state-trie>
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct StateMpt {
-    /// Values are always [`rlp`]-encoded [`AccountRlp`],
+    /// Values are always [`rlp`]-encoded [`Account`],
     /// inserted at [256 bits](MptKey::from_hash).
     inner: HashedPartialTrie,
 }
@@ -288,7 +289,7 @@ impl Default for StateMpt {
 }
 
 #[track_caller]
-fn assert_rlp_account(bytes: impl AsRef<[u8]>) -> AccountRlp {
+fn assert_rlp_account(bytes: impl AsRef<[u8]>) -> MptAccount {
     rlp::decode(bytes.as_ref()).expect("invalid RLP in StateMPT")
 }
 
@@ -303,20 +304,26 @@ impl StateMpt {
             ),
         }
     }
+    pub fn new_with_inner(inner: HashedPartialTrie) -> Self {
+        Self { inner }
+    }
     pub fn as_hashed_partial_trie(&self) -> &HashedPartialTrie {
         &self.inner
     }
+    pub fn as_mut_hashed_partial_trie(&mut self) -> &mut HashedPartialTrie {
+        &mut self.inner
+    }
     /// Insert a _hashed out_ part of the trie
     pub fn insert_hash(&mut self, key: MptKey, hash: H256) -> anyhow::Result<()> {
         Ok(self.inner.insert(key.into_nibbles(), hash)?)
     }
-    pub fn insert(&mut self, key: H256, account: AccountRlp) -> anyhow::Result<()> {
+    pub fn insert(&mut self, key: H256, account: MptAccount) -> anyhow::Result<()> {
         Ok(self.inner.insert(
             MptKey::from_hash(key).into_nibbles(),
             rlp::encode(&account).to_vec(),
         )?)
     }
-    pub fn get(&self, key: H256) -> Option<AccountRlp> {
+    pub fn get(&self, key: H256) -> Option<MptAccount> {
         self.inner
             .get(MptKey::from_hash(key).into_nibbles())
             .map(assert_rlp_account)
@@ -338,7 +345,7 @@ impl StateMpt {
         self.inner = new;
         Ok(())
     }
-    pub fn iter(&self) -> impl Iterator<Item = (H256, AccountRlp)> + '_ {
+    pub fn iter(&self) -> impl Iterator<Item = (H256, MptAccount)> + '_ {
         self.inner.items().filter_map(|(key, rlp)| match rlp {
             mpt_trie::trie_ops::ValOrHash::Val(vec) => Some((
                 MptKey::from_nibbles(key).into_hash().expect("bad depth"),
@@ -358,7 +365,7 @@ impl From<StateMpt> for HashedPartialTrie {
 /// Global, per-account.
 ///
 /// See <https://ethereum.org/en/developers/docs/data-structures-and-encoding/patricia-merkle-trie/#storage-trie>
-#[derive(Debug, Clone, Default)]
+#[derive(Debug, Clone, Default, Serialize, Deserialize)]
 pub struct StorageTrie {
     untyped: HashedPartialTrie,
 }
@@ -368,6 +375,9 @@ impl StorageTrie {
             untyped: HashedPartialTrie::new_with_strategy(Node::Empty, strategy),
         }
     }
+    pub fn new_with_trie(untyped: HashedPartialTrie) -> Self {
+        Self { untyped }
+    }
     pub fn get(&mut self, key: &MptKey) -> Option<&[u8]> {
         self.untyped.get(key.into_nibbles())
     }
diff --git a/evm_arithmetization/src/util.rs b/evm_arithmetization/src/util.rs
index a9aae2d2b..93acb7e7e 100644
--- a/evm_arithmetization/src/util.rs
+++ b/evm_arithmetization/src/util.rs
@@ -210,7 +210,7 @@ pub(crate) fn biguint_to_mem_vec(x: BigUint) -> Vec<U256> {
     mem_vec
 }
 
-pub(crate) fn h2u(h: H256) -> U256 {
+pub fn h2u(h: H256) -> U256 {
     U256::from_big_endian(&h.0)
 }
 
diff --git a/evm_arithmetization/src/witness/operation.rs b/evm_arithmetization/src/witness/operation.rs
index c8e2a5376..9af559c8a 100644
--- a/evm_arithmetization/src/witness/operation.rs
+++ b/evm_arithmetization/src/witness/operation.rs
@@ -243,7 +243,7 @@ pub(crate) fn generate_poseidon_general<F: RichField, T: Transition<F>>(
 
     let poseidon_op = PoseidonOp::PoseidonGeneralOp(PoseidonGeneralOp {
         base_address,
-        timestamp: clock * NUM_CHANNELS,
+        timestamp: clock * NUM_CHANNELS + 1,
         input: input.clone(),
         len: input.len(),
     });
@@ -886,6 +886,7 @@ pub(crate) fn generate_mload_general<F: RichField, T: Transition<F>>(
 
     state.push_memory(log_read);
     state.push_cpu(row);
+
     Ok(())
 }
 
diff --git a/evm_arithmetization/src/witness/transition.rs b/evm_arithmetization/src/witness/transition.rs
index fdcf9af65..c65dd7e18 100644
--- a/evm_arithmetization/src/witness/transition.rs
+++ b/evm_arithmetization/src/witness/transition.rs
@@ -1,4 +1,6 @@
+use ethereum_types::U256;
 use log::log_enabled;
+use mpt_trie::partial_trie::HashedPartialTrie;
 use plonky2::field::types::Field;
 use plonky2::hash::hash_types::RichField;
 
@@ -6,14 +8,24 @@ use super::util::stack_pop_with_log_and_fill;
 use crate::cpu::columns::CpuColumnsView;
 use crate::cpu::kernel::aggregator::KERNEL;
 use crate::cpu::kernel::constants::context_metadata::ContextMetadata;
+use crate::cpu::kernel::constants::global_metadata::GlobalMetadata;
 use crate::cpu::kernel::constants::MAX_CODE_SIZE;
 use crate::cpu::kernel::opcodes::get_opcode;
+#[cfg(test)]
+use crate::cpu::kernel::tests::mpt::linked_list::StateLinkedList;
+#[cfg(all(test, not(feature = "cdk_erigon")))]
+use crate::cpu::kernel::tests::mpt::linked_list::{AccountsLinkedList, StorageLinkedList};
 use crate::cpu::membus::NUM_GP_CHANNELS;
 use crate::cpu::stack::{
     EQ_STACK_BEHAVIOR, IS_ZERO_STACK_BEHAVIOR, JUMPI_OP, JUMP_OP, MIGHT_OVERFLOW, STACK_BEHAVIORS,
 };
+use crate::generation::linked_list::testing::LinkedList;
 use crate::generation::state::State;
+#[cfg(not(feature = "cdk_erigon"))]
+use crate::generation::trie_extractor::get_state_trie;
 use crate::memory::segments::Segment;
+// TO REMOVE!
+use crate::util::u256_to_usize;
 use crate::witness::errors::ProgramError;
 use crate::witness::gas::gas_to_charge;
 use crate::witness::memory::MemoryAddress;
@@ -282,10 +294,11 @@ pub(crate) const fn might_overflow_op(op: Operation) -> bool {
 }
 
 pub(crate) fn log_kernel_instruction<F: RichField, S: State<F>>(state: &mut S, op: Operation) {
+    // TODO: Revert
     // The logic below is a bit costly, so skip it if debug logs aren't enabled.
-    if !log_enabled!(log::Level::Debug) {
-        return;
-    }
+    // if !log_enabled!(log::Level::Debug) {
+    //     return;
+    // }
 
     let pc = state.get_registers().program_counter;
     let is_interesting_offset = KERNEL
@@ -309,6 +322,37 @@ pub(crate) fn log_kernel_instruction<F: RichField, S: State<F>>(state: &mut S, o
         ),
     );
 
+    #[cfg(test)]
+    if KERNEL.offset_name(pc) == "hash_state_trie" || KERNEL.offset_name(pc) == "sys_sstore" {
+        let mem = state
+            .get_generation_state()
+            .memory
+            .get_preinit_memory(Segment::AccountsLinkedList);
+        #[cfg(test)]
+        log::debug!(
+            "state linked list = {:?}",
+            StateLinkedList::from_mem_and_segment(&mem, Segment::AccountsLinkedList)
+        );
+        let root_ptr = u256_to_usize(
+            state
+                .get_generation_state()
+                .memory
+                .read_global_metadata(GlobalMetadata::StateTrieRoot),
+        )
+        .unwrap();
+        let mem = state
+            .get_generation_state()
+            .memory
+            .get_preinit_memory(Segment::TrieData);
+        log::debug!(
+            "state smt data = {:?}",
+            mem[root_ptr..]
+                .iter()
+                .map(|x| x.unwrap_or_default())
+                .collect::<Vec<U256>>()
+        );
+    }
+
     let kernel_code =
         &state.get_generation_state().memory.contexts[0].segments[Segment::Code.unscale()].content;
     assert!(pc < kernel_code.len(), "Kernel PC is out of range: {}", pc);
diff --git a/evm_arithmetization/src/world.rs b/evm_arithmetization/src/world.rs
index d01e7ef26..efbdd2611 100644
--- a/evm_arithmetization/src/world.rs
+++ b/evm_arithmetization/src/world.rs
@@ -5,8 +5,12 @@ use anyhow::{ensure, Context as _};
 use either::Either;
 use ethereum_types::{Address, BigEndianHash as _, U256};
 use keccak_hash::H256;
+use mpt_trie::partial_trie::HashedPartialTrie;
+use serde::{Deserialize, Serialize};
 use smt_trie::code::hash_bytecode_h256;
 
+use crate::tries::{MptKey, SmtKey, StateMpt, StorageTrie};
+
 /// Utility trait to leverage a specific hash function across Type1 and Type2
 /// zkEVM variants.
 pub trait Hasher {
@@ -28,7 +32,24 @@ impl Hasher for KeccakHash {
     }
 }
 
-use crate::tries::{MptKey, SmtKey, StateMpt, StorageTrie};
+#[derive(Clone, Debug, Deserialize, Serialize)]
+pub struct StateWorld {
+    pub state: Either<Type1World, Type2World>,
+}
+
+impl Default for StateWorld {
+    fn default() -> Self {
+        if cfg!(feature = "cdk_erigon") {
+            StateWorld {
+                state: Either::Right(Type2World::default()),
+            }
+        } else {
+            StateWorld {
+                state: Either::Left(Type1World::default()),
+            }
+        }
+    }
+}
 
 /// The `core` module of the `trace_decoder` crate is agnostic over state and
 /// storage representations.
@@ -63,11 +84,25 @@ pub trait World {
     /// Creates a new account at `address` if it does not exist.
     fn update_nonce(&mut self, address: Address, f: impl FnOnce(&mut U256)) -> anyhow::Result<()>;
 
+    /// Hash the provided code with this `World`'s [`CodeHasher`].
+    fn hash_code(&self, code: &[u8]) -> H256 {
+        Self::CodeHasher::hash(code)
+    }
+
     /// Update the code for the account at the given address.
     ///
     /// Creates a new account at `address` if it does not exist.
     fn set_code(&mut self, address: Address, code: Either<&[u8], H256>) -> anyhow::Result<()>;
 
+    /// Update the code and code length for the account at the give address.
+    ///
+    /// Creates a new account at `address` if it does not exist.
+    fn set_code_and_hash(
+        &mut self,
+        address: Address,
+        code: Either<H256, U256>,
+        code_length: Option<U256>,
+    );
     /// The `core` module of the `trace_decoder` crate tracks required subtries
     /// for proving.
     ///
@@ -116,7 +151,7 @@ pub trait World {
     fn root(&mut self) -> H256;
 }
 
-#[derive(Clone, Debug)]
+#[derive(Default, Clone, Debug, Deserialize, Serialize)]
 pub struct Type1World {
     state: StateMpt,
     /// Writes to storage should be reconciled with
@@ -144,15 +179,28 @@ impl Type1World {
     pub fn state_trie(&self) -> &mpt_trie::partial_trie::HashedPartialTrie {
         self.state.as_hashed_partial_trie()
     }
+    pub fn state_trie_mut(&mut self) -> &mut mpt_trie::partial_trie::HashedPartialTrie {
+        self.state.as_mut_hashed_partial_trie()
+    }
     pub fn into_state_and_storage(self) -> (StateMpt, BTreeMap<H256, StorageTrie>) {
         let Self { state, storage } = self;
         (state, storage)
     }
+    pub fn set_storage(&mut self, storage: BTreeMap<H256, StorageTrie>) {
+        self.storage = storage;
+    }
     fn get_storage_mut(&mut self, address: Address) -> anyhow::Result<&mut StorageTrie> {
         self.storage
             .get_mut(&keccak_hash::keccak(address))
             .context("no such storage")
     }
+    pub(crate) fn get_storage(&self) -> Vec<(H256, &HashedPartialTrie)> {
+        // TODO(Robin)
+        self.storage
+            .iter()
+            .map(|(key, value)| (*key, value.as_hashed_partial_trie()))
+            .collect::<Vec<_>>()
+    }
     fn on_storage<T>(
         &mut self,
         address: Address,
@@ -199,6 +247,16 @@ impl World for Type1World {
         acct.code_hash = code.right_or_else(Self::CodeHasher::hash);
         self.state.insert(key, acct)
     }
+    fn set_code_and_hash(
+        &mut self,
+        address: Address,
+        code: Either<H256, U256>,
+        _code_length: Option<U256>,
+    ) {
+        let key = keccak_hash::keccak(address);
+        let mut acct = self.state.get(key).unwrap_or_default();
+        acct.code_hash = code.expect_left("MPTs store hashes as H256.");
+    }
     fn reporting_destroy(&mut self, address: Address) -> anyhow::Result<Option<Self::SubtriePath>> {
         self.state.reporting_remove(address)
     }
@@ -308,6 +366,16 @@ impl World for Type2World {
         };
         Ok(())
     }
+    fn set_code_and_hash(
+        &mut self,
+        address: Address,
+        code: Either<H256, U256>,
+        code_length: Option<U256>,
+    ) {
+        let acct = self.accounts.entry(address).or_default();
+        acct.code_hash = Some(code.expect_right("SMTs store hashes as U256."));
+        acct.code_length = code_length;
+    }
     fn reporting_destroy(&mut self, address: Address) -> anyhow::Result<Option<Self::SubtriePath>> {
         self.accounts.remove(&address);
         Ok(None)
@@ -373,11 +441,145 @@ impl World for Type2World {
     }
 }
 
+#[cfg(not(feature = "cdk_erigon"))]
+pub(crate) type StateKey = MptKey;
+
+#[cfg(feature = "cdk_erigon")]
+pub(crate) type StateKey = SmtKey;
+
+#[cfg(not(feature = "cdk_erigon"))]
+pub(crate) type CodeHasher = KeccakHash;
+
+#[cfg(feature = "cdk_erigon")]
+pub(crate) type CodeHasher = PoseidonHash;
+
+impl World for StateWorld {
+    type SubtriePath = StateKey;
+    type CodeHasher = CodeHasher;
+
+    fn contains(&mut self, address: Address) -> anyhow::Result<bool> {
+        match &mut self.state {
+            Either::Left(type1) => type1.contains(address),
+            Either::Right(type2) => type2.contains(address),
+        }
+    }
+    fn update_balance(
+        &mut self,
+        address: Address,
+        f: impl FnOnce(&mut U256),
+    ) -> anyhow::Result<()> {
+        match &mut self.state {
+            Either::Left(type1) => type1.update_balance(address, f),
+            Either::Right(type2) => type2.update_balance(address, f),
+        }
+    }
+    fn update_nonce(&mut self, address: Address, f: impl FnOnce(&mut U256)) -> anyhow::Result<()> {
+        match &mut self.state {
+            Either::Left(type1) => type1.update_nonce(address, f),
+            Either::Right(type2) => type2.update_nonce(address, f),
+        }
+    }
+    fn set_code(&mut self, address: Address, code: Either<&[u8], H256>) -> anyhow::Result<()> {
+        match &mut self.state {
+            Either::Left(type1) => type1.set_code(address, code),
+            Either::Right(type2) => type2.set_code(address, code),
+        }
+    }
+    fn set_code_and_hash(
+        &mut self,
+        address: Address,
+        code_hash: Either<H256, U256>,
+        code_length: Option<U256>,
+    ) {
+        match &mut self.state {
+            Either::Left(type1) => type1.set_code_and_hash(address, code_hash, code_length),
+            Either::Right(type2) => type2.set_code_and_hash(address, code_hash, code_length),
+        }
+    }
+    fn reporting_destroy(&mut self, address: Address) -> anyhow::Result<Option<Self::SubtriePath>> {
+        // TODO: Find a way to revamp this
+        #[cfg(not(feature = "cdk_erigon"))]
+        match &mut self.state {
+            Either::Left(type1) => type1.reporting_destroy(address),
+            Either::Right(_type2) => unreachable!("Type2 is not supported."),
+        }
+        #[cfg(feature = "cdk_erigon")]
+        match &mut self.state {
+            Either::Left(_type1) => unreachable!("Type1 is not supported"),
+            Either::Right(type2) => type2.reporting_destroy(address),
+        }
+    }
+    fn create_storage(&mut self, address: Address) -> anyhow::Result<()> {
+        match &mut self.state {
+            Either::Left(type1) => type1.create_storage(address),
+            Either::Right(type2) => type2.create_storage(address),
+        }
+    }
+    fn destroy_storage(&mut self, address: Address) -> anyhow::Result<()> {
+        match &mut self.state {
+            Either::Left(type1) => type1.destroy_storage(address),
+            Either::Right(type2) => type2.destroy_storage(address),
+        }
+    }
+    fn store_int(&mut self, address: Address, slot: U256, value: U256) -> anyhow::Result<()> {
+        match &mut self.state {
+            Either::Left(type1) => type1.store_int(address, slot, value),
+            Either::Right(type2) => type2.store_int(address, slot, value),
+        }
+    }
+    fn store_hash(&mut self, address: Address, hash: H256, value: H256) -> anyhow::Result<()> {
+        match &mut self.state {
+            Either::Left(type1) => type1.store_hash(address, hash, value),
+            Either::Right(type2) => type2.store_hash(address, hash, value),
+        }
+    }
+    fn load_int(&mut self, address: Address, slot: U256) -> anyhow::Result<U256> {
+        match &mut self.state {
+            Either::Left(type1) => type1.load_int(address, slot),
+            Either::Right(type2) => type2.load_int(address, slot),
+        }
+    }
+    fn reporting_destroy_slot(
+        &mut self,
+        address: Address,
+        slot: U256,
+    ) -> anyhow::Result<Option<MptKey>> {
+        match &mut self.state {
+            Either::Left(type1) => type1.reporting_destroy_slot(address, slot),
+            Either::Right(type2) => type2.reporting_destroy_slot(address, slot),
+        }
+    }
+    fn mask_storage(&mut self, masks: BTreeMap<Address, BTreeSet<MptKey>>) -> anyhow::Result<()> {
+        match &mut self.state {
+            Either::Left(type1) => type1.mask_storage(masks),
+            Either::Right(type2) => type2.mask_storage(masks),
+        }
+    }
+    fn mask(&mut self, paths: impl IntoIterator<Item = Self::SubtriePath>) -> anyhow::Result<()> {
+        #[cfg(not(feature = "cdk_erigon"))]
+        match &mut self.state {
+            Either::Left(type1) => type1.mask(paths),
+            Either::Right(_type2) => unreachable!("Type2 is not supported."),
+        }
+        #[cfg(feature = "cdk_erigon")]
+        match &mut self.state {
+            Either::Left(_type1) => unreachable!("Type1 is not supported"),
+            Either::Right(type2) => type2.mask(paths),
+        }
+    }
+    fn root(&mut self) -> H256 {
+        match &mut self.state {
+            Either::Left(type1) => type1.root(),
+            Either::Right(type2) => type2.root(),
+        }
+    }
+}
+
 // Having optional fields here is an odd decision,
 // but without the distinction,
 // the wire tests fail.
 // This may be a bug in the SMT library.
-#[derive(Default, Clone, Debug)]
+#[derive(Default, Clone, Debug, Deserialize, Serialize)]
 pub struct Type2Entry {
     pub balance: Option<U256>,
     pub nonce: Option<U256>,
@@ -387,7 +589,7 @@ pub struct Type2Entry {
 }
 
 // This is a buffered version
-#[derive(Clone, Debug)]
+#[derive(Default, Clone, Debug, Deserialize, Serialize)]
 pub struct Type2World {
     accounts: BTreeMap<Address, Type2Entry>,
     hashed_out: BTreeMap<SmtKey, H256>,
diff --git a/evm_arithmetization/tests/add11_yml.rs b/evm_arithmetization/tests/add11_yml.rs
index 5406ebe6a..d242fd4fb 100644
--- a/evm_arithmetization/tests/add11_yml.rs
+++ b/evm_arithmetization/tests/add11_yml.rs
@@ -4,16 +4,18 @@ use std::collections::HashMap;
 use std::str::FromStr;
 use std::time::Duration;
 
+use either::Either;
 use ethereum_types::{Address, BigEndianHash, H256};
-use evm_arithmetization::generation::mpt::{AccountRlp, LegacyReceiptRlp};
+use evm_arithmetization::generation::mpt::{Account, EitherAccount, LegacyReceiptRlp, MptAccount};
 use evm_arithmetization::generation::TrieInputs;
 use evm_arithmetization::proof::{BlockHashes, BlockMetadata, TrieRoots};
 use evm_arithmetization::prover::testing::prove_all_segments;
 use evm_arithmetization::testing_utils::{
-    beacon_roots_account_nibbles, beacon_roots_contract_from_storage, init_logger,
+    beacon_roots_account_nibbles, beacon_roots_contract_from_storage, get_state_world, init_logger,
     preinitialized_state_and_storage_tries, update_beacon_roots_account_storage, TEST_STARK_CONFIG,
 };
 use evm_arithmetization::verifier::testing::verify_all_proofs;
+use evm_arithmetization::world::World;
 use evm_arithmetization::{AllStark, GenerationInputs, Node, EMPTY_CONSOLIDATED_BLOCKHASH};
 use hex_literal::hex;
 use keccak_hash::keccak;
@@ -33,6 +35,7 @@ fn get_generation_inputs() -> GenerationInputs {
     let sender = hex!("a94f5374fce5edbc8e2a8697c15331677e6ebf0b");
     let to = hex!("095e7baea6a6c7c4c2dfeb977efac326af552d87");
 
+    let rlp_default = EitherAccount::default();
     let beneficiary_state_key = keccak(beneficiary);
     let sender_state_key = keccak(sender);
     let to_hashed = keccak(to);
@@ -44,43 +47,54 @@ fn get_generation_inputs() -> GenerationInputs {
     let code = [0x60, 0x01, 0x60, 0x01, 0x01, 0x60, 0x00, 0x55, 0x00];
     let code_hash = keccak(code);
 
-    let beneficiary_account_before = AccountRlp {
+    let beneficiary_account_before = EitherAccount(Either::Left(MptAccount {
         nonce: 1.into(),
-        ..AccountRlp::default()
-    };
-    let sender_account_before = AccountRlp {
+        ..*rlp_default.as_mpt_account()
+    }));
+    let sender_account_before = EitherAccount(Either::Left(MptAccount {
         balance: 0x0de0b6b3a7640000u64.into(),
-        ..AccountRlp::default()
-    };
-    let to_account_before = AccountRlp {
+        ..*rlp_default.as_mpt_account()
+    }));
+    let to_account_before = EitherAccount(Either::Left(MptAccount {
         balance: 0x0de0b6b3a7640000u64.into(),
         code_hash,
-        ..AccountRlp::default()
-    };
+        ..*rlp_default.as_mpt_account()
+    }));
 
-    let (mut state_trie_before, mut storage_tries) =
+    let (mut state_trie_before_hashed, mut storage_tries) =
         preinitialized_state_and_storage_tries().unwrap();
     let mut beacon_roots_account_storage = storage_tries[0].1.clone();
-    state_trie_before
+    state_trie_before_hashed
         .insert(
             beneficiary_nibbles,
-            rlp::encode(&beneficiary_account_before).to_vec(),
+            beneficiary_account_before
+                .as_mpt_account()
+                .rlp_encode()
+                .to_vec(),
         )
         .unwrap();
-    state_trie_before
-        .insert(sender_nibbles, rlp::encode(&sender_account_before).to_vec())
+    state_trie_before_hashed
+        .insert(
+            sender_nibbles,
+            sender_account_before.as_mpt_account().rlp_encode().to_vec(),
+        )
         .unwrap();
-    state_trie_before
-        .insert(to_nibbles, rlp::encode(&to_account_before).to_vec())
+    state_trie_before_hashed
+        .insert(
+            to_nibbles,
+            to_account_before.as_mpt_account().rlp_encode().to_vec(),
+        )
         .unwrap();
 
     storage_tries.push((to_hashed, Node::Empty.into()));
 
+    let state_trie_before = get_state_world(state_trie_before_hashed, storage_tries);
+
     let tries_before = TrieInputs {
         state_trie: state_trie_before.clone(),
         transactions_trie: Node::Empty.into(),
         receipts_trie: Node::Empty.into(),
-        storage_tries,
+        // storage_tries,
     };
 
     let txn = hex!("f863800a83061a8094095e7baea6a6c7c4c2dfeb977efac326af552d87830186a0801ba0ffb600e63115a7362e7811894a91d8ba4330e526f22121c994c4692035dfdfd5a06198379fcac8de3dbfac48b165df4bf88e2088f294b61efb9a65fe2281c76e16");
@@ -112,16 +126,16 @@ fn get_generation_inputs() -> GenerationInputs {
         let beacon_roots_account =
             beacon_roots_contract_from_storage(&beacon_roots_account_storage);
 
-        let beneficiary_account_after = AccountRlp {
+        let beneficiary_account_after = EitherAccount(Either::Left(MptAccount {
             nonce: 1.into(),
-            ..AccountRlp::default()
-        };
-        let sender_account_after = AccountRlp {
+            ..*rlp_default.as_mpt_account()
+        }));
+        let sender_account_after = EitherAccount(Either::Left(MptAccount {
             balance: 0xde0b6b3a75be550u64.into(),
             nonce: 1.into(),
-            ..AccountRlp::default()
-        };
-        let to_account_after = AccountRlp {
+            ..*rlp_default.as_mpt_account()
+        }));
+        let to_account_after = EitherAccount(Either::Left(MptAccount {
             balance: 0xde0b6b3a76586a0u64.into(),
             code_hash,
             // Storage map: { 0 => 2 }
@@ -130,21 +144,30 @@ fn get_generation_inputs() -> GenerationInputs {
                 value: vec![2],
             })
             .hash(),
-            ..AccountRlp::default()
-        };
+            ..*rlp_default.as_mpt_account()
+        }));
 
         let mut expected_state_trie_after = HashedPartialTrie::from(Node::Empty);
         expected_state_trie_after
             .insert(
                 beneficiary_nibbles,
-                rlp::encode(&beneficiary_account_after).to_vec(),
+                beneficiary_account_after
+                    .as_mpt_account()
+                    .rlp_encode()
+                    .to_vec(),
             )
             .unwrap();
         expected_state_trie_after
-            .insert(sender_nibbles, rlp::encode(&sender_account_after).to_vec())
+            .insert(
+                sender_nibbles,
+                sender_account_after.as_mpt_account().rlp_encode().to_vec(),
+            )
             .unwrap();
         expected_state_trie_after
-            .insert(to_nibbles, rlp::encode(&to_account_after).to_vec())
+            .insert(
+                to_nibbles,
+                to_account_after.as_mpt_account().rlp_encode().to_vec(),
+            )
             .unwrap();
         expected_state_trie_after
             .insert(
@@ -189,7 +212,10 @@ fn get_generation_inputs() -> GenerationInputs {
         trie_roots_after,
         contract_code,
         block_metadata,
-        checkpoint_state_trie_root: state_trie_before.hash(),
+        checkpoint_state_trie_root: state_trie_before
+            .state
+            .expect_left("eth_mainnet expects MPTs.")
+            .root(),
         checkpoint_consolidated_hash: EMPTY_CONSOLIDATED_BLOCKHASH.map(F::from_canonical_u64),
         txn_number_before: 0.into(),
         gas_used_before: 0.into(),
diff --git a/evm_arithmetization/tests/erc20.rs b/evm_arithmetization/tests/erc20.rs
index f594c7bd3..5d34aae30 100644
--- a/evm_arithmetization/tests/erc20.rs
+++ b/evm_arithmetization/tests/erc20.rs
@@ -4,15 +4,11 @@ use std::str::FromStr;
 use std::time::Duration;
 
 use ethereum_types::{Address, BigEndianHash, H160, H256, U256};
-use evm_arithmetization::generation::mpt::{AccountRlp, LegacyReceiptRlp, LogRlp};
+use evm_arithmetization::generation::mpt::{LegacyReceiptRlp, LogRlp, MptAccount};
 use evm_arithmetization::generation::{GenerationInputs, TrieInputs};
 use evm_arithmetization::proof::{BlockHashes, BlockMetadata, TrieRoots};
 use evm_arithmetization::prover::testing::prove_all_segments;
-use evm_arithmetization::testing_utils::{
-    beacon_roots_account_nibbles, beacon_roots_contract_from_storage, create_account_storage,
-    init_logger, preinitialized_state_and_storage_tries, sd2u, update_beacon_roots_account_storage,
-    TEST_STARK_CONFIG,
-};
+use evm_arithmetization::testing_utils::*;
 use evm_arithmetization::verifier::testing::verify_all_proofs;
 use evm_arithmetization::{AllStark, Node, EMPTY_CONSOLIDATED_BLOCKHASH};
 use hex_literal::hex;
@@ -74,16 +70,27 @@ fn test_erc20() -> anyhow::Result<()> {
     state_trie_before.insert(giver_nibbles, rlp::encode(&giver_account()?).to_vec())?;
     state_trie_before.insert(token_nibbles, rlp::encode(&token_account()?).to_vec())?;
 
+    let account: MptAccount = rlp::decode(&vec![
+        248, 68, 128, 128, 160, 137, 205, 24, 134, 60, 67, 40, 191, 183, 72, 15, 201, 189, 37, 25,
+        188, 192, 83, 19, 163, 35, 250, 187, 2, 115, 42, 47, 21, 67, 41, 186, 215, 160, 245, 122,
+        205, 64, 37, 152, 114, 96, 109, 118, 25, 126, 240, 82, 243, 211, 85, 136, 218, 223, 145,
+        158, 225, 240, 227, 203, 155, 98, 211, 244, 176, 44,
+    ])
+    .unwrap();
+    log::debug!("real give acc ={:?}", account);
+    log::debug!("expected = {:?}", BEACON_ROOTS_ACCOUNT);
+
     storage_tries.extend([
         (giver_state_key, giver_storage()?),
         (token_state_key, token_storage()?),
     ]);
 
+    let state_trie_before = get_state_world(state_trie_before, storage_tries);
     let tries_before = TrieInputs {
         state_trie: state_trie_before,
         transactions_trie: HashedPartialTrie::from(Node::Empty),
         receipts_trie: HashedPartialTrie::from(Node::Empty),
-        storage_tries,
+        // storage_tries,
     };
 
     let txn = signed_tx();
@@ -117,16 +124,18 @@ fn test_erc20() -> anyhow::Result<()> {
         let beacon_roots_account =
             beacon_roots_contract_from_storage(&beacon_roots_account_storage);
 
+        log::debug!("final beacon roots acc = {:?}", beacon_roots_account);
+
         let mut state_trie_after = HashedPartialTrie::from(Node::Empty);
         let sender_account = sender_account();
-        let sender_account_after = AccountRlp {
+        let sender_account_after = MptAccount {
             nonce: sender_account.nonce + 1,
             balance: sender_account.balance - gas_used * 0xa,
             ..sender_account
         };
         state_trie_after.insert(sender_nibbles, rlp::encode(&sender_account_after).to_vec())?;
         state_trie_after.insert(giver_nibbles, rlp::encode(&giver_account()?).to_vec())?;
-        let token_account_after = AccountRlp {
+        let token_account_after = MptAccount {
             storage_root: token_storage_after()?.hash(),
             ..token_account()?
         };
@@ -139,6 +148,7 @@ fn test_erc20() -> anyhow::Result<()> {
         state_trie_after
     };
 
+    log::debug!("expected trie = {:?}", expected_state_trie_after);
     let receipt_0 = LegacyReceiptRlp {
         status: true,
         cum_gas_used: gas_used,
@@ -250,8 +260,9 @@ fn token_storage_after() -> anyhow::Result<HashedPartialTrie> {
     ])
 }
 
-fn giver_account() -> anyhow::Result<AccountRlp> {
-    Ok(AccountRlp {
+fn giver_account() -> anyhow::Result<MptAccount> {
+    log::debug!("giver bytecode {:?}", giver_bytecode());
+    Ok(MptAccount {
         nonce: 1.into(),
         balance: 0.into(),
         storage_root: giver_storage()?.hash(),
@@ -259,8 +270,8 @@ fn giver_account() -> anyhow::Result<AccountRlp> {
     })
 }
 
-fn token_account() -> anyhow::Result<AccountRlp> {
-    Ok(AccountRlp {
+fn token_account() -> anyhow::Result<MptAccount> {
+    Ok(MptAccount {
         nonce: 1.into(),
         balance: 0.into(),
         storage_root: token_storage()?.hash(),
@@ -268,8 +279,8 @@ fn token_account() -> anyhow::Result<AccountRlp> {
     })
 }
 
-fn sender_account() -> AccountRlp {
-    AccountRlp {
+fn sender_account() -> MptAccount {
+    MptAccount {
         nonce: 0.into(),
         balance: sd2u("10000000000000000000000"),
         storage_root: Default::default(),
diff --git a/evm_arithmetization/tests/erc20_type2.rs b/evm_arithmetization/tests/erc20_type2.rs
new file mode 100644
index 000000000..3b90f8711
--- /dev/null
+++ b/evm_arithmetization/tests/erc20_type2.rs
@@ -0,0 +1,397 @@
+#![cfg(feature = "cdk_erigon")]
+
+use std::collections::HashMap;
+use std::str::FromStr;
+use std::time::Duration;
+
+use either::Either;
+use ethereum_types::{Address, BigEndianHash, H160, H256, U256};
+use evm_arithmetization::generation::mpt::{Account, LegacyReceiptRlp, LogRlp, SmtAccount};
+use evm_arithmetization::generation::{GenerationInputs, TrieInputs};
+use evm_arithmetization::proof::{BlockHashes, BlockMetadata, TrieRoots};
+use evm_arithmetization::prover::testing::prove_all_segments;
+use evm_arithmetization::testing_utils::ADDRESS_SCALABLE_L2;
+use evm_arithmetization::testing_utils::LAST_BLOCK_STORAGE_POS;
+use evm_arithmetization::testing_utils::STATE_ROOT_STORAGE_POS;
+use evm_arithmetization::testing_utils::TIMESTAMP_STORAGE_POS;
+use evm_arithmetization::testing_utils::{init_logger, sd2u};
+use evm_arithmetization::verifier::testing::verify_all_proofs;
+use evm_arithmetization::world::{StateWorld, Type2World};
+use evm_arithmetization::{AllStark, Node, StarkConfig, EMPTY_CONSOLIDATED_BLOCKHASH};
+use hex_literal::hex;
+use keccak_hash::keccak;
+use mpt_trie::nibbles::Nibbles;
+use mpt_trie::partial_trie::{HashedPartialTrie, PartialTrie};
+use plonky2::field::goldilocks_field::GoldilocksField;
+use plonky2::field::types::Field;
+use plonky2::field::types::PrimeField64;
+use plonky2::plonk::config::KeccakGoldilocksConfig;
+use plonky2::util::timing::TimingTree;
+use smt_trie::code::hash_bytecode_h256;
+use smt_trie::db::{Db, MemoryDb};
+use smt_trie::keys::{key_balance, key_code, key_code_length, key_nonce, key_storage};
+use smt_trie::smt::Smt;
+use smt_trie::utils::hashout2u;
+
+type F = GoldilocksField;
+const D: usize = 2;
+type C = KeccakGoldilocksConfig;
+
+/// Test a simple ERC20 transfer.
+/// Used the following Solidity code:
+/// ```solidity
+/// pragma solidity ^0.8.13;
+/// import "../lib/openzeppelin-contracts/contracts/token/ERC20/ERC20.sol";
+/// contract Token is ERC20 {
+///     constructor() ERC20("Token", "TKN") {
+///         _mint(msg.sender, 1_000_000 ether);
+///     }
+/// }
+/// contract Giver {
+///     Token public token;
+///     constructor(address _token) {
+///         token = Token(_token);
+///     }
+///     function send(uint256 amount) public {
+///         token.transfer(0x1f9090aaE28b8a3dCeaDf281B0F12828e676c326, amount);
+///     }
+/// }
+/// ```
+#[test]
+fn test_erc20() -> anyhow::Result<()> {
+    init_logger();
+
+    let all_stark = AllStark::<F, D>::default();
+    let config = StarkConfig::standard_fast_config();
+
+    let beneficiary = hex!("deadbeefdeadbeefdeadbeefdeadbeefdeadbeef");
+    let sender = hex!("70997970C51812dc3A010C7d01b50e0d17dc79C8");
+    let giver = hex!("e7f1725E7734CE288F8367e1Bb143E90bb3F0512");
+    let token = hex!("5FbDB2315678afecb367f032d93F642f64180aa3");
+
+    // let mut state_smt_before = Smt::<MemoryDb>::default();
+    let mut state_smt_before = StateWorld::default();
+    println!("state_smt {:?}", state_smt_before);
+    set_account(
+        &mut state_smt_before,
+        H160(sender),
+        &sender_account(),
+        &HashMap::new(),
+        &vec![],
+    );
+    set_account(
+        &mut state_smt_before,
+        H160(giver),
+        &giver_account(),
+        &giver_storage(),
+        &giver_bytecode(),
+    );
+    set_account(
+        &mut state_smt_before,
+        H160(token),
+        &token_account(),
+        &token_storage(),
+        &token_bytecode(),
+    );
+
+    let state_smt_before_root = state_smt_before
+        .state
+        .clone()
+        .expect_right("cdk_erigon expects SMTs.")
+        .as_smt()
+        .root;
+
+    let tries_before = TrieInputs {
+        state_trie: state_smt_before,
+        transactions_trie: HashedPartialTrie::from(Node::Empty),
+        receipts_trie: HashedPartialTrie::from(Node::Empty),
+    };
+
+    let txn = signed_tx();
+
+    let gas_used = 56_499.into();
+    let bloom = bloom();
+    let block_metadata = BlockMetadata {
+        block_beneficiary: Address::from(beneficiary),
+        block_timestamp: 0x03e8.into(),
+        block_number: 1.into(),
+        block_difficulty: 0x020000.into(),
+        block_random: H256::from_uint(&0x020000.into()),
+        block_gaslimit: 0xff112233u32.into(),
+        block_chain_id: 1.into(),
+        block_base_fee: 0xa.into(),
+        block_gas_used: gas_used,
+        block_bloom: bloom,
+        ..Default::default()
+    };
+
+    let contract_code = [giver_bytecode(), token_bytecode(), vec![]]
+        .map(|v| (hash_bytecode_h256(&v), v))
+        .into();
+
+    let expected_smt_after: StateWorld = {
+        let mut smt = StateWorld::default();
+        let sender_account = sender_account();
+        let sender_account_after = SmtAccount {
+            nonce: sender_account.nonce + 1,
+            balance: sender_account.balance - gas_used * 0xa,
+            ..sender_account
+        };
+        set_account(
+            &mut smt,
+            H160(sender),
+            &sender_account_after,
+            &HashMap::new(),
+            &vec![],
+        );
+        set_account(
+            &mut smt,
+            H160(giver),
+            &giver_account(),
+            &giver_storage(),
+            &giver_bytecode(),
+        );
+        set_account(
+            &mut smt,
+            H160(token),
+            &token_account(),
+            &token_storage_after(),
+            &token_bytecode(),
+        );
+
+        set_account(
+            &mut smt,
+            ADDRESS_SCALABLE_L2,
+            &scalable_account(),
+            &scalable_storage_after(&block_metadata, hashout2u(state_smt_before_root)),
+            &vec![],
+        );
+
+        smt
+    };
+
+    let receipt_0 = LegacyReceiptRlp {
+        status: true,
+        cum_gas_used: gas_used,
+        bloom: bloom_bytes().to_vec().into(),
+        logs: vec![LogRlp {
+            address: H160::from_str("0x5fbdb2315678afecb367f032d93f642f64180aa3").unwrap(),
+            topics: vec![
+                H256::from_str(
+                    "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef",
+                )
+                .unwrap(),
+                H256::from_str(
+                    "0x000000000000000000000000e7f1725e7734ce288f8367e1bb143e90bb3f0512",
+                )
+                .unwrap(),
+                H256::from_str(
+                    "0x0000000000000000000000001f9090aae28b8a3dceadf281b0f12828e676c326",
+                )
+                .unwrap(),
+            ],
+            data: hex!("0000000000000000000000000000000000000000000000056bc75e2d63100000")
+                .to_vec()
+                .into(),
+        }],
+    };
+    let mut receipts_trie = HashedPartialTrie::from(Node::Empty);
+    receipts_trie.insert(Nibbles::from_str("0x80").unwrap(), receipt_0.encode(2))?;
+    let transactions_trie: HashedPartialTrie = Node::Leaf {
+        nibbles: Nibbles::from_str("0x80").unwrap(),
+        value: txn.to_vec(),
+    }
+    .into();
+
+    let kb = key_code_length(ADDRESS_SCALABLE_L2);
+    let expected_smt_after_as_smt = expected_smt_after
+        .state
+        .expect_right("cdk_erigon expects SMTs.")
+        .as_smt();
+    log::debug!(
+        "scalable code length key = {:?}",
+        U256(std::array::from_fn(|i| kb.0[i].to_canonical_u64()))
+    );
+    log::debug!("expected smt after = {:?}", expected_smt_after_as_smt);
+    log::debug!("expected smt data after = {:?}", expected_smt_after_as_smt);
+
+    let trie_roots_after = TrieRoots {
+        state_root: H256::from_uint(&hashout2u(expected_smt_after_as_smt.root)),
+        transactions_root: transactions_trie.hash(),
+        receipts_root: receipts_trie.hash(),
+    };
+
+    let inputs = GenerationInputs::<F> {
+        signed_txns: vec![txn.to_vec()],
+        burn_addr: None,
+        withdrawals: vec![],
+        ger_data: None,
+        tries: tries_before,
+        trie_roots_after,
+        contract_code,
+        checkpoint_state_trie_root: HashedPartialTrie::from(Node::Empty).hash(),
+        checkpoint_consolidated_hash: EMPTY_CONSOLIDATED_BLOCKHASH.map(F::from_canonical_u64),
+        block_metadata,
+        txn_number_before: 0.into(),
+        gas_used_before: 0.into(),
+        gas_used_after: gas_used,
+        block_hashes: BlockHashes {
+            prev_hashes: vec![H256::default(); 256],
+            cur_hash: H256::default(),
+        },
+    };
+
+    let max_cpu_len_log = 20;
+    let mut timing = TimingTree::new("prove", log::Level::Debug);
+
+    let proofs = prove_all_segments::<F, C, D>(
+        &all_stark,
+        &config,
+        inputs,
+        max_cpu_len_log,
+        &mut timing,
+        None,
+    )?;
+
+    timing.filter(Duration::from_millis(100)).print();
+
+    verify_all_proofs(&all_stark, &proofs, &config)
+}
+
+fn giver_bytecode() -> Vec<u8> {
+    hex!("608060405234801561001057600080fd5b50600436106100365760003560e01c8063a52c101e1461003b578063fc0c546a14610050575b600080fd5b61004e61004936600461010c565b61007f565b005b600054610063906001600160a01b031681565b6040516001600160a01b03909116815260200160405180910390f35b60005460405163a9059cbb60e01b8152731f9090aae28b8a3dceadf281b0f12828e676c3266004820152602481018390526001600160a01b039091169063a9059cbb906044016020604051808303816000875af11580156100e4573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906101089190610125565b5050565b60006020828403121561011e57600080fd5b5035919050565b60006020828403121561013757600080fd5b8151801515811461014757600080fd5b939250505056fea264697066735822122050741efdbac11eb0bbb776ce3ac6004e596b7d7559658a12506164388c371cfd64736f6c63430008140033").into()
+}
+
+fn token_bytecode() -> Vec<u8> {
+    hex!("608060405234801561001057600080fd5b50600436106100935760003560e01c8063313ce56711610066578063313ce567146100fe57806370a082311461010d57806395d89b4114610136578063a9059cbb1461013e578063dd62ed3e1461015157600080fd5b806306fdde0314610098578063095ea7b3146100b657806318160ddd146100d957806323b872dd146100eb575b600080fd5b6100a061018a565b6040516100ad919061056a565b60405180910390f35b6100c96100c43660046105d4565b61021c565b60405190151581526020016100ad565b6002545b6040519081526020016100ad565b6100c96100f93660046105fe565b610236565b604051601281526020016100ad565b6100dd61011b36600461063a565b6001600160a01b031660009081526020819052604090205490565b6100a061025a565b6100c961014c3660046105d4565b610269565b6100dd61015f36600461065c565b6001600160a01b03918216600090815260016020908152604080832093909416825291909152205490565b6060600380546101999061068f565b80601f01602080910402602001604051908101604052809291908181526020018280546101c59061068f565b80156102125780601f106101e757610100808354040283529160200191610212565b820191906000526020600020905b8154815290600101906020018083116101f557829003601f168201915b5050505050905090565b60003361022a818585610277565b60019150505b92915050565b600033610244858285610289565b61024f85858561030c565b506001949350505050565b6060600480546101999061068f565b60003361022a81858561030c565b610284838383600161036b565b505050565b6001600160a01b03838116600090815260016020908152604080832093861683529290522054600019811461030657818110156102f757604051637dc7a0d960e11b81526001600160a01b038416600482015260248101829052604481018390526064015b60405180910390fd5b6103068484848403600061036b565b50505050565b6001600160a01b03831661033657604051634b637e8f60e11b8152600060048201526024016102ee565b6001600160a01b0382166103605760405163ec442f0560e01b8152600060048201526024016102ee565b610284838383610440565b6001600160a01b0384166103955760405163e602df0560e01b8152600060048201526024016102ee565b6001600160a01b0383166103bf57604051634a1406b160e11b8152600060048201526024016102ee565b6001600160a01b038085166000908152600160209081526040808320938716835292905220829055801561030657826001600160a01b0316846001600160a01b03167f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b9258460405161043291815260200190565b60405180910390a350505050565b6001600160a01b03831661046b57806002600082825461046091906106c9565b909155506104dd9050565b6001600160a01b038316600090815260208190526040902054818110156104be5760405163391434e360e21b81526001600160a01b038516600482015260248101829052604481018390526064016102ee565b6001600160a01b03841660009081526020819052604090209082900390555b6001600160a01b0382166104f957600280548290039055610518565b6001600160a01b03821660009081526020819052604090208054820190555b816001600160a01b0316836001600160a01b03167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef8360405161055d91815260200190565b60405180910390a3505050565b600060208083528351808285015260005b818110156105975785810183015185820160400152820161057b565b506000604082860101526040601f19601f8301168501019250505092915050565b80356001600160a01b03811681146105cf57600080fd5b919050565b600080604083850312156105e757600080fd5b6105f0836105b8565b946020939093013593505050565b60008060006060848603121561061357600080fd5b61061c846105b8565b925061062a602085016105b8565b9150604084013590509250925092565b60006020828403121561064c57600080fd5b610655826105b8565b9392505050565b6000806040838503121561066f57600080fd5b610678836105b8565b9150610686602084016105b8565b90509250929050565b600181811c908216806106a357607f821691505b6020821081036106c357634e487b7160e01b600052602260045260246000fd5b50919050565b8082018082111561023057634e487b7160e01b600052601160045260246000fdfea2646970667358221220266a323ae4a816f6c6342a5be431fedcc0d45c44b02ea75f5474eb450b5d45b364736f6c63430008140033").into()
+}
+
+fn giver_storage() -> HashMap<U256, U256> {
+    let mut storage = HashMap::new();
+    storage.insert(
+        U256::zero(),
+        sd2u("546584486846459126461364135121053344201067465379"),
+    );
+    storage
+}
+
+fn token_storage() -> HashMap<U256, U256> {
+    let mut storage = HashMap::new();
+    storage.insert(
+        sd2u("82183438603287090451672504949863617512989139203883434767553028632841710582583"),
+        sd2u("1000000000000000000000"),
+    );
+    storage
+}
+
+fn token_storage_after() -> HashMap<U256, U256> {
+    let mut storage = HashMap::new();
+    storage.insert(
+        sd2u("82183438603287090451672504949863617512989139203883434767553028632841710582583"),
+        sd2u("900000000000000000000"),
+    );
+    storage.insert(
+        sd2u("53006154680716014998529145169423020330606407246856709517064848190396281160729"),
+        sd2u("100000000000000000000"),
+    );
+    storage
+}
+
+fn scalable_storage_after(block: &BlockMetadata, state_root_before: U256) -> HashMap<U256, U256> {
+    let mut storage = HashMap::new();
+    storage.insert(U256::from(LAST_BLOCK_STORAGE_POS.1), block.block_number);
+    storage.insert(U256::from(TIMESTAMP_STORAGE_POS.1), block.block_timestamp);
+
+    let mut arr = [0; 64];
+    (block.block_number - U256::one()).to_big_endian(&mut arr[0..32]);
+    U256::from(STATE_ROOT_STORAGE_POS.1).to_big_endian(&mut arr[32..64]);
+    let slot = keccak(arr);
+    storage.insert(slot.into_uint(), state_root_before);
+    storage
+}
+
+fn giver_account() -> SmtAccount {
+    let code = giver_bytecode();
+    let len = code.len();
+    SmtAccount {
+        nonce: 1.into(),
+        balance: 0.into(),
+        code_hash: hash_bytecode_h256(&code).into_uint(),
+        code_length: len.into(),
+    }
+}
+
+fn token_account() -> SmtAccount {
+    let code = token_bytecode();
+    let len = code.len();
+    SmtAccount {
+        nonce: 1.into(),
+        balance: 0.into(),
+        code_hash: hash_bytecode_h256(&code).into_uint(),
+        code_length: len.into(),
+    }
+}
+
+fn sender_account() -> SmtAccount {
+    SmtAccount {
+        nonce: 0.into(),
+        balance: sd2u("10000000000000000000000"),
+        ..Default::default()
+    }
+}
+
+fn scalable_account() -> SmtAccount {
+    SmtAccount {
+        nonce: 0.into(),
+        balance: 0.into(),
+        ..Default::default()
+    }
+}
+
+fn signed_tx() -> Vec<u8> {
+    hex!("02f88701800a0a830142c594e7f1725e7734ce288f8367e1bb143e90bb3f051280a4a52c101e0000000000000000000000000000000000000000000000056bc75e2d63100000c001a0303f5591159d7ea303faecb1c8bd8624b55732f769de28b111190dfb9a7c5234a019d5d6d38938dc1c63acbe106cf361672def773ace4ca587860117d057326627").into()
+}
+
+fn bloom_bytes() -> [u8; 256] {
+    hex!("00000000000000000400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008000000000008000000000000000000000000000000000040000000000000000000000000000000000000000000000014000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000002000000000000000000000000000000000000000000000042000000000000000000000000000000000000000000020000000000080000000000000000000000000000000000000000000000000000000000000000")
+}
+
+fn bloom() -> [U256; 8] {
+    let bloom = bloom_bytes()
+        .chunks_exact(32)
+        .map(U256::from_big_endian)
+        .collect::<Vec<_>>();
+    bloom.try_into().unwrap()
+}
+
+fn set_account(
+    world: &mut StateWorld,
+    addr: Address,
+    account: &SmtAccount,
+    storage: &HashMap<U256, U256>,
+    code: &[u8],
+) {
+    use evm_arithmetization::world::World;
+
+    let key = key_balance(addr);
+    log::debug!(
+        "setting {:?} balance to {:?}, the key is {:?}",
+        addr,
+        account.get_balance(),
+        U256(std::array::from_fn(|i| key.0[i].to_canonical_u64()))
+    );
+    if let Either::Right(ref mut smt_state) = world.state {
+        smt_state.update_balance(addr, |b| *b = account.get_balance());
+        smt_state.update_nonce(addr, |n| *n = account.get_nonce());
+        smt_state.set_code(addr, Either::Left(code));
+        let key = key_code_length(addr);
+        log::debug!(
+            "setting {:?} code length, the key is {:?}",
+            addr,
+            U256(std::array::from_fn(|i| key.0[i].to_canonical_u64()))
+        );
+        for (&k, &v) in storage {
+            smt_state.store_int(addr, k, v);
+        }
+    }
+}
diff --git a/evm_arithmetization/tests/erc721.rs b/evm_arithmetization/tests/erc721.rs
index e39915100..2138bddcd 100644
--- a/evm_arithmetization/tests/erc721.rs
+++ b/evm_arithmetization/tests/erc721.rs
@@ -4,15 +4,11 @@ use std::str::FromStr;
 use std::time::Duration;
 
 use ethereum_types::{Address, BigEndianHash, H160, H256, U256};
-use evm_arithmetization::generation::mpt::{AccountRlp, LegacyReceiptRlp, LogRlp};
+use evm_arithmetization::generation::mpt::{LegacyReceiptRlp, LogRlp, MptAccount};
 use evm_arithmetization::generation::{GenerationInputs, TrieInputs};
 use evm_arithmetization::proof::{BlockHashes, BlockMetadata, TrieRoots};
 use evm_arithmetization::prover::testing::prove_all_segments;
-use evm_arithmetization::testing_utils::{
-    beacon_roots_account_nibbles, beacon_roots_contract_from_storage, create_account_storage,
-    init_logger, preinitialized_state_and_storage_tries, sd2u, sh2u,
-    update_beacon_roots_account_storage, TEST_STARK_CONFIG,
-};
+use evm_arithmetization::testing_utils::*;
 use evm_arithmetization::verifier::testing::verify_all_proofs;
 use evm_arithmetization::{AllStark, Node, EMPTY_CONSOLIDATED_BLOCKHASH};
 use hex_literal::hex;
@@ -79,11 +75,12 @@ fn test_erc721() -> anyhow::Result<()> {
 
     storage_tries.push((contract_state_key, contract_storage()?));
 
+    let state_trie_before = get_state_world(state_trie_before, storage_tries);
     let tries_before = TrieInputs {
         state_trie: state_trie_before,
         transactions_trie: HashedPartialTrie::from(Node::Empty),
         receipts_trie: HashedPartialTrie::from(Node::Empty),
-        storage_tries,
+        // storage_tries,
     };
 
     let txn = signed_tx();
@@ -143,13 +140,13 @@ fn test_erc721() -> anyhow::Result<()> {
             beacon_roots_contract_from_storage(&beacon_roots_account_storage);
 
         let owner_account = owner_account();
-        let owner_account_after = AccountRlp {
+        let owner_account_after = MptAccount {
             nonce: owner_account.nonce + 1,
             balance: owner_account.balance - gas_used * 0xa,
             ..owner_account
         };
         state_trie_after.insert(owner_nibbles, rlp::encode(&owner_account_after).to_vec())?;
-        let contract_account_after = AccountRlp {
+        let contract_account_after = MptAccount {
             storage_root: contract_storage_after()?.hash(),
             ..contract_account()?
         };
@@ -276,8 +273,8 @@ fn contract_storage_after() -> anyhow::Result<HashedPartialTrie> {
     ])
 }
 
-fn owner_account() -> AccountRlp {
-    AccountRlp {
+fn owner_account() -> MptAccount {
+    MptAccount {
         nonce: 2.into(),
         balance: 0x1000000.into(),
         storage_root: HashedPartialTrie::from(Node::Empty).hash(),
@@ -285,8 +282,8 @@ fn owner_account() -> AccountRlp {
     }
 }
 
-fn contract_account() -> anyhow::Result<AccountRlp> {
-    Ok(AccountRlp {
+fn contract_account() -> anyhow::Result<MptAccount> {
+    Ok(MptAccount {
         nonce: 0.into(),
         balance: 0.into(),
         storage_root: contract_storage()?.hash(),
diff --git a/evm_arithmetization/tests/global_exit_root.rs b/evm_arithmetization/tests/global_exit_root.rs
index 5495d4100..7c2934132 100644
--- a/evm_arithmetization/tests/global_exit_root.rs
+++ b/evm_arithmetization/tests/global_exit_root.rs
@@ -1,19 +1,17 @@
 #![cfg(feature = "cdk_erigon")]
 
-use std::collections::HashMap;
+use std::collections::{BTreeMap, HashMap};
 use std::time::Duration;
 
+use either::Either;
 use ethereum_types::H256;
 use evm_arithmetization::generation::{GenerationInputs, TrieInputs};
 use evm_arithmetization::proof::{BlockHashes, BlockMetadata, TrieRoots};
 use evm_arithmetization::prover::testing::prove_all_segments;
-use evm_arithmetization::testing_utils::{
-    ger_account_nibbles, ger_contract_from_storage, init_logger, scalable_account_nibbles,
-    scalable_contract_from_storage, update_ger_account_storage, update_scalable_account_storage,
-    ADDRESS_SCALABLE_L2_ADDRESS_HASHED, GLOBAL_EXIT_ROOT_ACCOUNT, GLOBAL_EXIT_ROOT_ADDRESS_HASHED,
-    TEST_STARK_CONFIG,
-};
+use evm_arithmetization::testing_utils::*;
+use evm_arithmetization::tries::{StateMpt, StorageTrie};
 use evm_arithmetization::verifier::testing::verify_all_proofs;
+use evm_arithmetization::world::{StateWorld, Type1World};
 use evm_arithmetization::{AllStark, Node, EMPTY_CONSOLIDATED_BLOCKHASH};
 use keccak_hash::keccak;
 use mpt_trie::partial_trie::{HashedPartialTrie, PartialTrie};
@@ -26,108 +24,113 @@ type F = GoldilocksField;
 const D: usize = 2;
 type C = PoseidonGoldilocksConfig;
 
-/// Test pre-state execution as performed by cdk-erigon.
-#[test]
-fn test_global_exit_root() -> anyhow::Result<()> {
-    init_logger();
-
-    let all_stark = AllStark::<F, D>::default();
-    let config = TEST_STARK_CONFIG;
-
-    let block_metadata = BlockMetadata {
-        block_timestamp: 1.into(),
-        block_number: 42.into(),
-        ..BlockMetadata::default()
-    };
-
-    let mut state_trie_before = HashedPartialTrie::from(Node::Empty);
-    let mut storage_tries = vec![];
-    state_trie_before.insert(
-        ger_account_nibbles(),
-        rlp::encode(&GLOBAL_EXIT_ROOT_ACCOUNT).to_vec(),
-    )?;
-
-    let mut ger_account_storage = HashedPartialTrie::from(Node::Empty);
-    let mut scalable_account_storage = HashedPartialTrie::from(Node::Empty);
-
-    storage_tries.push((GLOBAL_EXIT_ROOT_ADDRESS_HASHED, ger_account_storage.clone()));
-    storage_tries.push((
-        ADDRESS_SCALABLE_L2_ADDRESS_HASHED,
-        scalable_account_storage.clone(),
-    ));
-
-    let transactions_trie = HashedPartialTrie::from(Node::Empty);
-    let receipts_trie = HashedPartialTrie::from(Node::Empty);
-
-    let mut contract_code = HashMap::new();
-    contract_code.insert(keccak(vec![]), vec![]);
-
-    let ger_data = Some((H256::random(), H256::random()));
-
-    let state_trie_after = {
-        let mut trie = HashedPartialTrie::from(Node::Empty);
-        update_ger_account_storage(&mut ger_account_storage, ger_data)?;
-        update_scalable_account_storage(
-            &mut scalable_account_storage,
-            &block_metadata,
-            state_trie_before.hash(),
-        )?;
-
-        let ger_account = ger_contract_from_storage(&ger_account_storage);
-        let scalable_account = scalable_contract_from_storage(&scalable_account_storage);
-
-        trie.insert(ger_account_nibbles(), rlp::encode(&ger_account).to_vec())?;
-        trie.insert(
-            scalable_account_nibbles(),
-            rlp::encode(&scalable_account).to_vec(),
-        )?;
-
-        trie
-    };
-
-    let trie_roots_after = TrieRoots {
-        state_root: state_trie_after.hash(),
-        transactions_root: transactions_trie.hash(),
-        receipts_root: receipts_trie.hash(),
-    };
-
-    let inputs = GenerationInputs::<F> {
-        signed_txns: vec![],
-        burn_addr: None,
-        withdrawals: vec![],
-        ger_data,
-        tries: TrieInputs {
-            state_trie: state_trie_before,
-            transactions_trie,
-            receipts_trie,
-            storage_tries,
-        },
-        trie_roots_after,
-        contract_code,
-        checkpoint_state_trie_root: HashedPartialTrie::from(Node::Empty).hash(),
-        checkpoint_consolidated_hash: EMPTY_CONSOLIDATED_BLOCKHASH.map(F::from_canonical_u64),
-        block_metadata,
-        txn_number_before: 0.into(),
-        gas_used_before: 0.into(),
-        gas_used_after: 0.into(),
-        block_hashes: BlockHashes {
-            prev_hashes: vec![H256::default(); 256],
-            cur_hash: H256::default(),
-        },
-    };
-
-    let max_cpu_len_log = 20;
-
-    let mut timing = TimingTree::new("prove", log::Level::Debug);
-    let proofs = prove_all_segments::<F, C, D>(
-        &all_stark,
-        &config,
-        inputs,
-        max_cpu_len_log,
-        &mut timing,
-        None,
-    )?;
-    timing.filter(Duration::from_millis(100)).print();
-
-    verify_all_proofs(&all_stark, &proofs, &config)
-}
+// /// Test pre-state execution as performed by cdk-erigon.
+// TODO: fix this with SMT
+// #[test]
+// fn test_global_exit_root() -> anyhow::Result<()> {
+//     init_logger();
+
+//     let all_stark = AllStark::<F, D>::default();
+//     let config = TEST_STARK_CONFIG;
+
+//     let block_metadata = BlockMetadata {
+//         block_timestamp: 1.into(),
+//         block_number: 42.into(),
+//         ..BlockMetadata::default()
+//     };
+
+//     let mut state_trie_before = HashedPartialTrie::from(Node::Empty);
+//     let mut storage_tries = vec![];
+//     state_trie_before.insert(
+//         ger_account_nibbles(),
+//         rlp::encode(&GLOBAL_EXIT_ROOT_ACCOUNT).to_vec(),
+//     )?;
+
+//     let mut ger_account_storage = HashedPartialTrie::from(Node::Empty);
+//     let mut scalable_account_storage = HashedPartialTrie::from(Node::Empty);
+
+//     storage_tries.push((GLOBAL_EXIT_ROOT_ADDRESS_HASHED,
+// ger_account_storage.clone()));     storage_tries.push((
+//         ADDRESS_SCALABLE_L2_ADDRESS_HASHED,
+//         scalable_account_storage.clone(),
+//     ));
+
+//     let transactions_trie = HashedPartialTrie::from(Node::Empty);
+//     let receipts_trie = HashedPartialTrie::from(Node::Empty);
+
+//     let mut contract_code = HashMap::new();
+//     contract_code.insert(keccak(vec![]), vec![]);
+
+//     let ger_data = Some((H256::random(), H256::random()));
+
+//     let state_trie_after = {
+//         let mut trie = HashedPartialTrie::from(Node::Empty);
+//         update_ger_account_storage(&mut ger_account_storage, ger_data)?;
+//         update_scalable_account_storage(
+//             &mut scalable_account_storage,
+//             &block_metadata,
+//             state_trie_before.hash(),
+//         )?;
+
+//         let ger_account = ger_contract_from_storage(&ger_account_storage);
+//         let scalable_account =
+// scalable_contract_from_storage(&scalable_account_storage);
+
+//         trie.insert(ger_account_nibbles(),
+// rlp::encode(&ger_account).to_vec())?;         trie.insert(
+//             scalable_account_nibbles(),
+//             rlp::encode(&scalable_account).to_vec(),
+//         )?;
+
+//         trie
+//     };
+
+//     let trie_roots_after = TrieRoots {
+//         state_root: state_trie_after.hash(),
+//         transactions_root: transactions_trie.hash(),
+//         receipts_root: receipts_trie.hash(),
+//     };
+
+//     let state_trie_before = get_state_world(state_trie_before,
+// storage_tries);     let inputs = GenerationInputs::<F> {
+//         signed_txns: vec![],
+//         burn_addr: None,
+//         withdrawals: vec![],
+//         ger_data,
+//         tries: TrieInputs {
+//             state_trie: state_trie_before,
+//             transactions_trie,
+//             receipts_trie,
+//             // storage_tries,
+//         },
+//         trie_roots_after,
+//         contract_code,
+//         checkpoint_state_trie_root:
+// HashedPartialTrie::from(Node::Empty).hash(),
+//         checkpoint_consolidated_hash:
+// EMPTY_CONSOLIDATED_BLOCKHASH.map(F::from_canonical_u64),
+//         block_metadata,
+//         txn_number_before: 0.into(),
+//         gas_used_before: 0.into(),
+//         gas_used_after: 0.into(),
+//         block_hashes: BlockHashes {
+//             prev_hashes: vec![H256::default(); 256],
+//             cur_hash: H256::default(),
+//         },
+//     };
+
+//     let max_cpu_len_log = 20;
+
+//     let mut timing = TimingTree::new("prove", log::Level::Debug);
+//     let proofs = prove_all_segments::<F, C, D>(
+//         &all_stark,
+//         &config,
+//         inputs,
+//         max_cpu_len_log,
+//         &mut timing,
+//         None,
+//     )?;
+//     timing.filter(Duration::from_millis(100)).print();
+
+//     verify_all_proofs(&all_stark, &proofs, &config)
+// }
diff --git a/evm_arithmetization/tests/log_opcode.rs b/evm_arithmetization/tests/log_opcode.rs
index 4f274b0b9..212683ec9 100644
--- a/evm_arithmetization/tests/log_opcode.rs
+++ b/evm_arithmetization/tests/log_opcode.rs
@@ -9,14 +9,11 @@ use ethereum_types::{Address, BigEndianHash, H256};
 use evm_arithmetization::generation::mpt::transaction_testing::{
     AddressOption, LegacyTransactionRlp,
 };
-use evm_arithmetization::generation::mpt::{AccountRlp, LegacyReceiptRlp, LogRlp};
+use evm_arithmetization::generation::mpt::{LegacyReceiptRlp, LogRlp, MptAccount};
 use evm_arithmetization::generation::{GenerationInputs, TrieInputs};
 use evm_arithmetization::proof::{BlockHashes, BlockMetadata, TrieRoots};
 use evm_arithmetization::prover::testing::prove_all_segments;
-use evm_arithmetization::testing_utils::{
-    beacon_roots_account_nibbles, beacon_roots_contract_from_storage, init_logger,
-    preinitialized_state_and_storage_tries, update_beacon_roots_account_storage, TEST_STARK_CONFIG,
-};
+use evm_arithmetization::testing_utils::*;
 use evm_arithmetization::verifier::testing::verify_all_proofs;
 use evm_arithmetization::{AllStark, Node, EMPTY_CONSOLIDATED_BLOCKHASH};
 use hex_literal::hex;
@@ -72,20 +69,20 @@ fn test_log_opcodes() -> anyhow::Result<()> {
     let code_hash = keccak(code);
 
     // Set accounts before the transaction.
-    let beneficiary_account_before = AccountRlp {
+    let beneficiary_account_before = MptAccount {
         nonce: 1.into(),
-        ..AccountRlp::default()
+        ..MptAccount::default()
     };
 
     let sender_balance_before = 5000000000000000u64;
-    let sender_account_before = AccountRlp {
+    let sender_account_before = MptAccount {
         balance: sender_balance_before.into(),
-        ..AccountRlp::default()
+        ..MptAccount::default()
     };
-    let to_account_before = AccountRlp {
+    let to_account_before = MptAccount {
         balance: 9000000000u64.into(),
         code_hash,
-        ..AccountRlp::default()
+        ..MptAccount::default()
     };
 
     // Initialize the state trie with three accounts.
@@ -129,11 +126,12 @@ fn test_log_opcodes() -> anyhow::Result<()> {
         rlp::encode(&receipt_0).to_vec(),
     )?;
 
+    let state_trie_before = get_state_world(state_trie_before, storage_tries);
     let tries_before = TrieInputs {
         state_trie: state_trie_before,
         transactions_trie: Node::Empty.into(),
         receipts_trie: receipts_trie.clone(),
-        storage_tries,
+        // storage_tries,
     };
 
     // Prove a transaction which carries out two LOG opcodes.
@@ -159,27 +157,27 @@ fn test_log_opcodes() -> anyhow::Result<()> {
     // Update the state and receipt tries after the transaction, so that we have the
     // correct expected tries: Update accounts
     #[cfg(feature = "cdk_erigon")]
-    let beneficiary_account_after = AccountRlp {
+    let beneficiary_account_after = Account {
         nonce: 1.into(),
         balance: block_metadata.block_base_fee * gas_used,
-        ..AccountRlp::default()
+        ..Account::default()
     };
-    #[cfg(not(feature = "cdk_erigon"))]
-    let beneficiary_account_after = AccountRlp {
+    #[cfg(feature = "eth_mainnet")]
+    let beneficiary_account_after = MptAccount {
         nonce: 1.into(),
-        ..AccountRlp::default()
+        ..MptAccount::default()
     };
 
     let sender_balance_after = sender_balance_before - gas_used * txn_gas_price;
-    let sender_account_after = AccountRlp {
+    let sender_account_after = MptAccount {
         balance: sender_balance_after.into(),
         nonce: 1.into(),
-        ..AccountRlp::default()
+        ..MptAccount::default()
     };
-    let to_account_after = AccountRlp {
+    let to_account_after = MptAccount {
         balance: 9000000000u64.into(),
         code_hash,
-        ..AccountRlp::default()
+        ..MptAccount::default()
     };
 
     update_beacon_roots_account_storage(
diff --git a/evm_arithmetization/tests/selfdestruct.rs b/evm_arithmetization/tests/selfdestruct.rs
index e528ae804..c43a48ee4 100644
--- a/evm_arithmetization/tests/selfdestruct.rs
+++ b/evm_arithmetization/tests/selfdestruct.rs
@@ -4,14 +4,11 @@ use std::str::FromStr;
 use std::time::Duration;
 
 use ethereum_types::{Address, BigEndianHash, H256};
-use evm_arithmetization::generation::mpt::{AccountRlp, LegacyReceiptRlp};
+use evm_arithmetization::generation::mpt::{LegacyReceiptRlp, MptAccount};
 use evm_arithmetization::generation::{GenerationInputs, TrieInputs};
 use evm_arithmetization::proof::{BlockHashes, BlockMetadata, TrieRoots};
 use evm_arithmetization::prover::testing::prove_all_segments;
-use evm_arithmetization::testing_utils::{
-    beacon_roots_account_nibbles, beacon_roots_contract_from_storage, init_logger,
-    preinitialized_state_and_storage_tries, update_beacon_roots_account_storage, TEST_STARK_CONFIG,
-};
+use evm_arithmetization::testing_utils::*;
 use evm_arithmetization::verifier::testing::verify_all_proofs;
 use evm_arithmetization::{AllStark, Node, EMPTY_CONSOLIDATED_BLOCKHASH};
 use hex_literal::hex;
@@ -46,7 +43,7 @@ fn test_selfdestruct() -> anyhow::Result<()> {
     let sender_nibbles = Nibbles::from_bytes_be(sender_state_key.as_bytes()).unwrap();
     let to_nibbles = Nibbles::from_bytes_be(to_state_key.as_bytes()).unwrap();
 
-    let sender_account_before = AccountRlp {
+    let sender_account_before = MptAccount {
         nonce: 5.into(),
         balance: eth_to_wei(100_000.into()),
         storage_root: HashedPartialTrie::from(Node::Empty).hash(),
@@ -56,7 +53,7 @@ fn test_selfdestruct() -> anyhow::Result<()> {
         0x32, // ORIGIN
         0xFF, // SELFDESTRUCT
     ];
-    let to_account_before = AccountRlp {
+    let to_account_before = MptAccount {
         nonce: 12.into(),
         balance: eth_to_wei(10_000.into()),
         storage_root: HashedPartialTrie::from(Node::Empty).hash(),
@@ -68,11 +65,12 @@ fn test_selfdestruct() -> anyhow::Result<()> {
     state_trie_before.insert(sender_nibbles, rlp::encode(&sender_account_before).to_vec())?;
     state_trie_before.insert(to_nibbles, rlp::encode(&to_account_before).to_vec())?;
 
+    let state_trie_before = get_state_world(state_trie_before, storage_tries);
     let tries_before = TrieInputs {
         state_trie: state_trie_before,
         transactions_trie: HashedPartialTrie::from(Node::Empty),
         receipts_trie: HashedPartialTrie::from(Node::Empty),
-        storage_tries,
+        // storage_tries,
     };
 
     // Generated using a little py-evm script.
@@ -91,7 +89,7 @@ fn test_selfdestruct() -> anyhow::Result<()> {
         ..Default::default()
     };
 
-    let contract_code = [(keccak(&code), code.clone()), (keccak([]), vec![])].into();
+    let contract_code = [(keccak(&code), code.clone()), (keccak(&[]), vec![])].into();
 
     let expected_state_trie_after: HashedPartialTrie = {
         let mut state_trie_after = HashedPartialTrie::from(Node::Empty);
@@ -104,7 +102,7 @@ fn test_selfdestruct() -> anyhow::Result<()> {
         let beacon_roots_account =
             beacon_roots_contract_from_storage(&beacon_roots_account_storage);
 
-        let sender_account_after = AccountRlp {
+        let sender_account_after = MptAccount {
             nonce: 6.into(),
             balance: eth_to_wei(110_000.into()) - 26_002 * 0xa,
             storage_root: HashedPartialTrie::from(Node::Empty).hash(),
@@ -114,7 +112,7 @@ fn test_selfdestruct() -> anyhow::Result<()> {
 
         // EIP-6780: The account won't be deleted because it wasn't created during this
         // transaction.
-        let to_account_before = AccountRlp {
+        let to_account_before = MptAccount {
             nonce: 12.into(),
             balance: 0.into(),
             storage_root: HashedPartialTrie::from(Node::Empty).hash(),
diff --git a/evm_arithmetization/tests/simple_transfer.rs b/evm_arithmetization/tests/simple_transfer.rs
index 6d2cbb6d0..d239f7815 100644
--- a/evm_arithmetization/tests/simple_transfer.rs
+++ b/evm_arithmetization/tests/simple_transfer.rs
@@ -5,14 +5,11 @@ use std::str::FromStr;
 use std::time::Duration;
 
 use ethereum_types::{Address, BigEndianHash, H256, U256};
-use evm_arithmetization::generation::mpt::{AccountRlp, LegacyReceiptRlp};
+use evm_arithmetization::generation::mpt::{LegacyReceiptRlp, MptAccount};
 use evm_arithmetization::generation::{GenerationInputs, TrieInputs};
 use evm_arithmetization::proof::{BlockHashes, BlockMetadata, TrieRoots};
 use evm_arithmetization::prover::testing::prove_all_segments;
-use evm_arithmetization::testing_utils::{
-    beacon_roots_account_nibbles, beacon_roots_contract_from_storage, init_logger,
-    preinitialized_state_and_storage_tries, update_beacon_roots_account_storage, TEST_STARK_CONFIG,
-};
+use evm_arithmetization::testing_utils::*;
 use evm_arithmetization::verifier::testing::verify_all_proofs;
 use evm_arithmetization::{AllStark, Node, EMPTY_CONSOLIDATED_BLOCKHASH};
 use hex_literal::hex;
@@ -47,23 +44,24 @@ fn test_simple_transfer() -> anyhow::Result<()> {
     let sender_nibbles = Nibbles::from_bytes_be(sender_state_key.as_bytes()).unwrap();
     let to_nibbles = Nibbles::from_bytes_be(to_state_key.as_bytes()).unwrap();
 
-    let sender_account_before = AccountRlp {
+    let sender_account_before = MptAccount {
         nonce: 5.into(),
         balance: eth_to_wei(100_000.into()),
         storage_root: HashedPartialTrie::from(Node::Empty).hash(),
         code_hash: keccak([]),
     };
-    let to_account_before = AccountRlp::default();
+    let to_account_before = MptAccount::default();
 
     let (mut state_trie_before, storage_tries) = preinitialized_state_and_storage_tries()?;
     let mut beacon_roots_account_storage = storage_tries[0].1.clone();
     state_trie_before.insert(sender_nibbles, rlp::encode(&sender_account_before).to_vec())?;
 
+    let state_trie_before = get_state_world(state_trie_before, storage_tries);
     let tries_before = TrieInputs {
         state_trie: state_trie_before,
         transactions_trie: HashedPartialTrie::from(Node::Empty),
         receipts_trie: HashedPartialTrie::from(Node::Empty),
-        storage_tries,
+        // storage_tries,
     };
 
     // Generated using a little py-evm script.
@@ -100,12 +98,14 @@ fn test_simple_transfer() -> anyhow::Result<()> {
         let beacon_roots_account =
             beacon_roots_contract_from_storage(&beacon_roots_account_storage);
 
-        let sender_account_after = AccountRlp {
+        log::debug!("beacon roots expected account:: {:?}", beacon_roots_account);
+
+        let sender_account_after = MptAccount {
             balance: sender_account_before.balance - value - gas_used * 10,
             nonce: sender_account_before.nonce + 1,
             ..sender_account_before
         };
-        let to_account_after = AccountRlp {
+        let to_account_after = MptAccount {
             balance: value,
             ..to_account_before
         };
diff --git a/evm_arithmetization/tests/two_to_one_block.rs b/evm_arithmetization/tests/two_to_one_block.rs
index 2ae171258..e7c5116a6 100644
--- a/evm_arithmetization/tests/two_to_one_block.rs
+++ b/evm_arithmetization/tests/two_to_one_block.rs
@@ -8,10 +8,7 @@ use evm_arithmetization::generation::{GenerationInputs, TrieInputs};
 use evm_arithmetization::proof::{
     BlockMetadata, FinalPublicValues, PublicValues, TrieRoots, EMPTY_CONSOLIDATED_BLOCKHASH,
 };
-use evm_arithmetization::testing_utils::{
-    beacon_roots_account_nibbles, beacon_roots_contract_from_storage, init_logger,
-    preinitialized_state_and_storage_tries, update_beacon_roots_account_storage, TEST_STARK_CONFIG,
-};
+use evm_arithmetization::testing_utils::*;
 use evm_arithmetization::{AllRecursiveCircuits, AllStark, Node, StarkConfig};
 use hex_literal::hex;
 use mpt_trie::partial_trie::{HashedPartialTrie, PartialTrie};
@@ -65,9 +62,11 @@ fn dummy_payload(timestamp: u64, is_first_payload: bool) -> anyhow::Result<Gener
         storage_tries[0].1 = beacon_roots_account_storage;
     }
 
+    let state_trie_before = get_state_world(state_trie_before, storage_tries);
+
     let tries_before = TrieInputs {
         state_trie: state_trie_before,
-        storage_tries,
+        // storage_tries,
         ..Default::default()
     };
 
diff --git a/evm_arithmetization/tests/withdrawals.rs b/evm_arithmetization/tests/withdrawals.rs
index f179d7b7e..5f71ecbf8 100644
--- a/evm_arithmetization/tests/withdrawals.rs
+++ b/evm_arithmetization/tests/withdrawals.rs
@@ -4,14 +4,11 @@ use std::collections::HashMap;
 use std::time::Duration;
 
 use ethereum_types::{H160, H256, U256};
-use evm_arithmetization::generation::mpt::AccountRlp;
+use evm_arithmetization::generation::mpt::MptAccount;
 use evm_arithmetization::generation::{GenerationInputs, TrieInputs};
 use evm_arithmetization::proof::{BlockHashes, BlockMetadata, TrieRoots};
 use evm_arithmetization::prover::testing::prove_all_segments;
-use evm_arithmetization::testing_utils::{
-    beacon_roots_account_nibbles, beacon_roots_contract_from_storage, init_logger,
-    preinitialized_state_and_storage_tries, update_beacon_roots_account_storage, TEST_STARK_CONFIG,
-};
+use evm_arithmetization::testing_utils::*;
 use evm_arithmetization::verifier::testing::verify_all_proofs;
 use evm_arithmetization::{AllStark, Node, EMPTY_CONSOLIDATED_BLOCKHASH};
 use keccak_hash::keccak;
@@ -63,9 +60,9 @@ fn test_withdrawals() -> anyhow::Result<()> {
 
         let addr_state_key = keccak(withdrawals[0].0);
         let addr_nibbles = Nibbles::from_bytes_be(addr_state_key.as_bytes()).unwrap();
-        let account = AccountRlp {
+        let account = MptAccount {
             balance: withdrawals[0].1,
-            ..AccountRlp::default()
+            ..MptAccount::default()
         };
         trie.insert(addr_nibbles, rlp::encode(&account).to_vec())?;
         trie.insert(
@@ -82,6 +79,7 @@ fn test_withdrawals() -> anyhow::Result<()> {
         receipts_root: receipts_trie.hash(),
     };
 
+    let state_trie_before = get_state_world(state_trie_before, storage_tries);
     let inputs = GenerationInputs::<F> {
         signed_txns: vec![],
         burn_addr: None,
@@ -91,7 +89,7 @@ fn test_withdrawals() -> anyhow::Result<()> {
             state_trie: state_trie_before,
             transactions_trie,
             receipts_trie,
-            storage_tries,
+            // storage_tries,
         },
         trie_roots_after,
         contract_code,
diff --git a/mpt_trie/src/debug_tools/diff.rs b/mpt_trie/src/debug_tools/diff.rs
index 6b0fb8c97..197c8c648 100644
--- a/mpt_trie/src/debug_tools/diff.rs
+++ b/mpt_trie/src/debug_tools/diff.rs
@@ -707,7 +707,7 @@ mod tests {
         #[derive(
             RlpEncodable, RlpDecodable, Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord,
         )]
-        pub struct TestAccountRlp {
+        pub struct TestAccount {
             pub nonce: U256,
             pub balance: U256,
             pub storage_root: H256,
@@ -717,7 +717,7 @@ mod tests {
         let mut data = vec![
             (
                 keccak(hex::decode("f0d4c12a5768d806021f80a262b4d39d26c58b8d").unwrap()),
-                TestAccountRlp {
+                TestAccount {
                     nonce: U256::from(1),
                     balance: U256::from(2),
                     storage_root: H256::from_uint(&1312378.into()),
@@ -726,7 +726,7 @@ mod tests {
             ),
             (
                 keccak(hex::decode("95222290dd7278aa3ddd389cc1e1d165cc4bafe5").unwrap()),
-                TestAccountRlp {
+                TestAccount {
                     nonce: U256::from(2),
                     balance: U256::from(3),
                     storage_root: H256::from_uint(&1123178.into()),
@@ -735,7 +735,7 @@ mod tests {
             ),
             (
                 keccak(hex::decode("43682bcf1ce452a70b72c109551084076c6377e0").unwrap()),
-                TestAccountRlp {
+                TestAccount {
                     nonce: U256::from(100),
                     balance: U256::from(101),
                     storage_root: H256::from_uint(&12345678.into()),
@@ -744,7 +744,7 @@ mod tests {
             ),
             (
                 keccak(hex::decode("97a9a15168c22b3c137e6381037e1499c8ad0978").unwrap()),
-                TestAccountRlp {
+                TestAccount {
                     nonce: U256::from(3000),
                     balance: U256::from(3002),
                     storage_root: H256::from_uint(&123456781.into()),
@@ -753,7 +753,7 @@ mod tests {
             ),
         ];
 
-        let create_trie_with_data = |trie: &Vec<(H256, TestAccountRlp)>| -> Result<HashedPartialTrie, Box<dyn std::error::Error>> {
+        let create_trie_with_data = |trie: &Vec<(H256, TestAccount)>| -> Result<HashedPartialTrie, Box<dyn std::error::Error>> {
             let mut tr = HashedPartialTrie::default();
             tr.insert::<Nibbles, &[u8]>(Nibbles::from_str(&hex::encode(trie[0].0.as_bytes()))?, rlp::encode(&trie[0].1).as_ref())?;
             tr.insert::<Nibbles, &[u8]>(Nibbles::from_str(&hex::encode(trie[1].0.as_bytes()))?, rlp::encode(&trie[1].1).as_ref())?;
diff --git a/mpt_trie/src/trie_hashing.rs b/mpt_trie/src/trie_hashing.rs
index c5e4a5ba7..451767363 100644
--- a/mpt_trie/src/trie_hashing.rs
+++ b/mpt_trie/src/trie_hashing.rs
@@ -90,6 +90,7 @@ fn append_to_stream(s: &mut RlpStream, node: EncodedNode) {
 }
 
 fn hash_bytes(bytes: &Bytes) -> [u8; 32] {
+    log::debug!("hashing bytes = {:?}", bytes.as_ref());
     keccak(bytes).0
 }
 
diff --git a/smt_trie/Cargo.toml b/smt_trie/Cargo.toml
index 6df15c11c..94f93a0ec 100644
--- a/smt_trie/Cargo.toml
+++ b/smt_trie/Cargo.toml
@@ -12,9 +12,12 @@ homepage.workspace = true
 keywords.workspace = true
 
 [dependencies]
-ethereum-types.workspace = true
-plonky2.workspace = true
-rand.workspace = true
+ethereum-types = { workspace = true }
+hex-literal = { workspace = true }
+log = { workspace = true }
+mpt_trie = { workspace = true }
+plonky2 = { workspace = true }
+rand = { workspace = true }
 serde = { workspace = true, features = ["derive", "rc"] }
 
 [dev-dependencies]
diff --git a/smt_trie/src/db.rs b/smt_trie/src/db.rs
index f71fad29a..b622c2ff7 100644
--- a/smt_trie/src/db.rs
+++ b/smt_trie/src/db.rs
@@ -1,5 +1,7 @@
 use std::collections::HashMap;
 
+use serde::{Deserialize, Serialize};
+
 use crate::smt::{Key, Node};
 
 pub trait Db: Default {
@@ -7,7 +9,7 @@ pub trait Db: Default {
     fn set_node(&mut self, key: Key, value: Node);
 }
 
-#[derive(Debug, Clone, Default)]
+#[derive(Debug, Clone, Default, Serialize, Deserialize)]
 pub struct MemoryDb {
     pub db: HashMap<Key, Node>,
 }
diff --git a/smt_trie/src/smt.rs b/smt_trie/src/smt.rs
index f9ea73319..136b4094b 100644
--- a/smt_trie/src/smt.rs
+++ b/smt_trie/src/smt.rs
@@ -1,16 +1,20 @@
 #![allow(clippy::needless_range_loop)]
 
+use core::fmt::Debug;
 use std::borrow::Borrow;
-use std::collections::{HashMap, HashSet};
+use std::collections::{BTreeMap, HashMap, HashSet};
+use std::fmt::{Display, Formatter};
 
-use ethereum_types::U256;
+use ethereum_types::{H256, U256};
+use mpt_trie::partial_trie::HashedPartialTrie;
 use plonky2::field::goldilocks_field::GoldilocksField;
 use plonky2::field::types::{Field, PrimeField64};
 use plonky2::hash::poseidon::{Poseidon, PoseidonHash};
 use plonky2::plonk::config::Hasher;
+use serde::{Deserialize, Serialize};
 
 use crate::bits::Bits;
-use crate::db::Db;
+use crate::db::{Db, MemoryDb};
 use crate::utils::{
     f2limbs, get_unique_sibling, hash0, hash_key_hash, hashout2u, key2u, limbs2f, u2h, u2k,
 };
@@ -20,9 +24,10 @@ pub(crate) const INTERNAL_TYPE: u8 = 1;
 pub(crate) const LEAF_TYPE: u8 = 2;
 
 pub type F = GoldilocksField;
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
 pub struct Key(pub [F; 4]);
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
 pub struct Node(pub [F; 12]);
 pub type Hash = PoseidonHash;
 pub type HashOut = <PoseidonHash as Hasher<F>>::Hash;
@@ -82,7 +87,7 @@ impl Node {
 /// subtree. Internal nodes hold the hashes of their children.
 /// The root is the hash of the root internal node.
 /// Leaves are hashed using a prefix of 0, internal nodes using a prefix of 1.
-#[derive(Debug, Clone, PartialEq, Eq, Default)]
+#[derive(Debug, Clone, PartialEq, Eq, Default, Serialize, Deserialize)]
 pub struct Smt<D: Db> {
     pub db: D,
     pub kv_store: HashMap<Key, U256>,
@@ -404,6 +409,7 @@ impl<D: Db> Smt<D> {
     /// Serialize and prune the SMT into a vector of U256.
     /// Starts with a [0, 0] for convenience, that way `ptr=0` is a canonical
     /// empty node. Therefore the root of the SMT is at `ptr=2`.
+    /// TODO: this convention changes with "hashing in the end".
     /// `keys` is a list of keys whose prefixes will not be hashed-out in the
     /// serialization.
     /// Serialization rules:
@@ -415,8 +421,9 @@ impl<D: Db> Smt<D> {
     pub fn serialize_and_prune<K: Borrow<Key>, I: IntoIterator<Item = K>>(
         &self,
         keys: I,
-    ) -> Vec<U256> {
-        let mut v = vec![U256::zero(); 2]; // For empty hash node.
+        v: &mut Vec<U256>,
+        offset: usize,
+    ) {
         let key = Key(self.root.elements);
 
         let mut keys_to_include = HashSet::new();
@@ -431,16 +438,70 @@ impl<D: Db> Smt<D> {
             }
         }
 
-        serialize(self, key, &mut v, Bits::empty(), &keys_to_include);
+        serialize(self, key, v, Bits::empty(), &keys_to_include, offset);
         if v.len() == 2 {
             v.extend([U256::zero(); 2]);
         }
+    }
+
+    pub fn load_linked_list_data<const OFFSET: usize>(
+        &self,
+        linked_list_mem: &mut Vec<Option<U256>>,
+        state_ptrs: &mut BTreeMap<U256, usize>,
+    ) {
+        let mut kv_sorted_by_k: Vec<(U256, U256)> = self
+            .kv_store
+            .iter()
+            .map(|(&key, &val)| (key2u(key), val))
+            .collect();
+        kv_sorted_by_k.sort_by(|(k1, _), (k2, _)| k1.cmp(k2));
+        // The next node of the dummy node must be the first node. If the
+        // list is empty, this value is set to its original value after
+        // the loop
+        linked_list_mem[3] = Some(U256::from(OFFSET + 4));
+        for (i, &(key, value)) in kv_sorted_by_k.iter().enumerate() {
+            // The nibbles are the address.
+            linked_list_mem.push(Some(key));
+            log::debug!("setting linked_list_mem[i + 0] to {:?}", key);
+            // Set the value.
+            linked_list_mem.push(Some(value));
+            log::debug!("setting linked_list_mem[i + 1] to {:?}", value);
+            // Set the original value.
+            linked_list_mem.push(Some(value));
+            log::debug!("setting linked_list_mem[i + 2] to {:?}", value);
+            // Set the next node as the initial node.
+            linked_list_mem.push(Some(U256::from(OFFSET + 4 * (i + 2))));
+            log::debug!("setting linked_list_mem[i + 3] to {:?}", U256::from(OFFSET));
+
+            // Put the pointer in state_ptrs
+            state_ptrs.insert(key, OFFSET + 4 * (i + 1));
+        }
+        // the lats node must point to the initial node
+        let last_index = linked_list_mem.len() - 1;
+        linked_list_mem[last_index] = Some(U256::from(OFFSET));
+    }
+
+    pub fn to_vec(&self) -> Vec<U256> {
+        // Include all keys.
+        let mut v = vec![U256::zero(); 2]; // For empty hash node.
+        self.serialize_and_prune(self.kv_store.keys(), &mut v, 0);
         v
     }
 
-    pub fn serialize(&self) -> Vec<U256> {
+    pub fn to_vec_skip_empty_node_and_add_offset(&self, offset: usize) -> Vec<U256> {
         // Include all keys.
-        self.serialize_and_prune(self.kv_store.keys())
+        let mut v = vec![]; // No empty hash node.
+        self.serialize_and_prune(self.kv_store.keys(), &mut v, offset);
+        v
+    }
+}
+
+impl Display for Smt<MemoryDb> {
+    fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
+        for (key, val) in self.kv_store.iter().map(|(&key, &val)| (key2u(key), val)) {
+            write!(f, "({:?}, {:?})\n", key, val)?;
+        }
+        Ok(())
     }
 }
 
@@ -450,6 +511,7 @@ fn serialize<D: Db>(
     v: &mut Vec<U256>,
     cur_bits: Bits,
     keys_to_include: &HashSet<Bits>,
+    offset: usize,
 ) -> usize {
     if key.0.iter().all(F::is_zero) {
         return 0; // `ptr=0` is an empty node.
@@ -459,7 +521,12 @@ fn serialize<D: Db>(
         let index = v.len();
         v.push(HASH_TYPE.into());
         v.push(key2u(key));
-        index
+        if index == 0 {
+            // Empty hash node is at the beggining of the segment
+            index
+        } else {
+            index + offset
+        }
     } else if let Some(node) = smt.db.get_node(&key) {
         if node.0.iter().all(F::is_zero) {
             panic!("wtf?");
@@ -476,7 +543,7 @@ fn serialize<D: Db>(
             v.push(LEAF_TYPE.into());
             v.push(key2u(rem_key));
             v.push(val);
-            index
+            index + offset
         } else {
             let key_left = Key(node.0[0..4].try_into().unwrap());
             let key_right = Key(node.0[4..8].try_into().unwrap());
@@ -484,13 +551,100 @@ fn serialize<D: Db>(
             v.push(INTERNAL_TYPE.into());
             v.push(U256::zero());
             v.push(U256::zero());
-            let i_left =
-                serialize(smt, key_left, v, cur_bits.add_bit(false), keys_to_include).into();
+            let i_left = serialize(
+                smt,
+                key_left,
+                v,
+                cur_bits.add_bit(false),
+                keys_to_include,
+                offset,
+            )
+            .into();
             v[index + 1] = i_left;
-            let i_right =
-                serialize(smt, key_right, v, cur_bits.add_bit(true), keys_to_include).into();
+            let i_right = serialize(
+                smt,
+                key_right,
+                v,
+                cur_bits.add_bit(true),
+                keys_to_include,
+                offset,
+            )
+            .into();
             v[index + 2] = i_right;
-            index
+            index + offset
+        }
+    } else {
+        unreachable!()
+    }
+}
+
+fn _load_linked_list_data_with_key_and_bits<D: Db, const OFFSET: usize>(
+    smt: &Smt<D>,
+    key: Key,
+    cur_bits: Bits,
+    linked_list_mem: &mut Vec<Option<U256>>,
+    state_ptrs: &mut BTreeMap<U256, usize>,
+) {
+    if key.0.iter().all(F::is_zero) {
+        return;
+    }
+
+    if let Some(node) = smt.db.get_node(&key) {
+        if node.0.iter().all(F::is_zero) {
+            panic!("wtf?");
+        }
+
+        if node.is_one_siblings() {
+            let val_h = node.0[4..8].try_into().unwrap();
+            let val_a = smt.db.get_node(&Key(val_h)).unwrap().0[0..8]
+                .try_into()
+                .unwrap();
+            let rem_key = Key(node.0[0..4].try_into().unwrap());
+            let val = limbs2f(val_a);
+
+            // The last leaf must point to the new one.
+            let len = linked_list_mem.len();
+            linked_list_mem[len - 1] = Some(U256::from(OFFSET + len));
+            log::debug!(
+                "setting linked_list_mem[{len} - 1] to {:?}",
+                U256::from(OFFSET + len)
+            );
+            // The nibbles are the address.
+            linked_list_mem.push(Some(key2u(rem_key)));
+            log::debug!("setting linked_list_mem[{len}] to {:?}", key2u(rem_key));
+            // Set the value.
+            linked_list_mem.push(Some(val));
+            log::debug!("setting linked_list_mem[{len} + 1] to {:?}", val);
+            // Set the original value.
+            linked_list_mem.push(Some(val));
+            log::debug!("setting linked_list_mem[{len} + 2] to {:?}", val);
+            // Set the next node as the initial node.
+            linked_list_mem.push(Some(U256::from(OFFSET)));
+            log::debug!(
+                "setting linked_list_mem[{len} + 3] to {:?}",
+                U256::from(OFFSET)
+            );
+
+            // Put the pointer in state_ptrs
+            state_ptrs.insert(key2u(rem_key), OFFSET + len);
+        } else {
+            let key_left = Key(node.0[0..4].try_into().unwrap());
+            let key_right = Key(node.0[4..8].try_into().unwrap());
+
+            _load_linked_list_data_with_key_and_bits::<_, OFFSET>(
+                smt,
+                key_left,
+                cur_bits.add_bit(false),
+                linked_list_mem,
+                state_ptrs,
+            );
+            _load_linked_list_data_with_key_and_bits::<_, OFFSET>(
+                smt,
+                key_right,
+                cur_bits.add_bit(true),
+                linked_list_mem,
+                state_ptrs,
+            );
         }
     } else {
         unreachable!()
@@ -533,3 +687,9 @@ fn _hash_serialize(v: &[U256], ptr: usize) -> HashOut {
         _ => panic!("Should not happen"),
     }
 }
+
+impl<D: Db> From<(HashedPartialTrie, Vec<(H256, HashedPartialTrie)>)> for Smt<D> {
+    fn from(_: (HashedPartialTrie, Vec<(H256, HashedPartialTrie)>)) -> Self {
+        todo!()
+    }
+}
diff --git a/smt_trie/src/smt_test.rs b/smt_trie/src/smt_test.rs
index c086e17dc..d862b39a6 100644
--- a/smt_trie/src/smt_test.rs
+++ b/smt_trie/src/smt_test.rs
@@ -25,7 +25,7 @@ fn test_add_and_rem() {
     smt.set(k, U256::zero());
     assert_eq!(smt.root.elements, [F::ZERO; 4]);
 
-    let ser = smt.serialize();
+    let ser = smt.to_vec();
     assert_eq!(hash_serialize(&ser), smt.root);
 }
 
@@ -51,7 +51,7 @@ fn test_add_and_rem_hermez() {
     smt.set(k, U256::zero());
     assert_eq!(smt.root.elements, [F::ZERO; 4]);
 
-    let ser = smt.serialize();
+    let ser = smt.to_vec();
     assert_eq!(hash_serialize(&ser), smt.root);
 }
 
@@ -68,7 +68,7 @@ fn test_update_element_1() {
     smt.set(k, v1);
     assert_eq!(smt.root, root);
 
-    let ser = smt.serialize();
+    let ser = smt.to_vec();
     assert_eq!(hash_serialize(&ser), smt.root);
 }
 
@@ -87,7 +87,7 @@ fn test_add_shared_element_2() {
     smt.set(k2, U256::zero());
     assert_eq!(smt.root.elements, [F::ZERO; 4]);
 
-    let ser = smt.serialize();
+    let ser = smt.to_vec();
     assert_eq!(hash_serialize(&ser), smt.root);
 }
 
@@ -109,7 +109,7 @@ fn test_add_shared_element_3() {
     smt.set(k3, U256::zero());
     assert_eq!(smt.root.elements, [F::ZERO; 4]);
 
-    let ser = smt.serialize();
+    let ser = smt.to_vec();
     assert_eq!(hash_serialize(&ser), smt.root);
 }
 
@@ -133,7 +133,7 @@ fn test_add_remove_128() {
     }
     assert_eq!(smt.root.elements, [F::ZERO; 4]);
 
-    let ser = smt.serialize();
+    let ser = smt.to_vec();
     assert_eq!(hash_serialize(&ser), smt.root);
 }
 
@@ -156,7 +156,7 @@ fn test_should_read_random() {
         assert_eq!(smt.get(k), v);
     }
 
-    let ser = smt.serialize();
+    let ser = smt.to_vec();
     assert_eq!(hash_serialize(&ser), smt.root);
 }
 
@@ -182,7 +182,7 @@ fn test_add_element_similar_key() {
     .map(F::from_canonical_u64);
     assert_eq!(smt.root.elements, expected_root);
 
-    let ser = smt.serialize();
+    let ser = smt.to_vec();
     assert_eq!(hash_serialize(&ser), smt.root);
 }
 
@@ -259,7 +259,7 @@ fn test_leaf_one_level_depth() {
     .map(F::from_canonical_u64);
     assert_eq!(smt.root.elements, expected_root);
 
-    let ser = smt.serialize();
+    let ser = smt.to_vec();
     assert_eq!(hash_serialize(&ser), smt.root);
 }
 
@@ -275,7 +275,7 @@ fn test_no_write_0() {
     smt.set(k2, U256::zero());
     assert_eq!(smt.root, root);
 
-    let ser = smt.serialize();
+    let ser = smt.to_vec();
     assert_eq!(hash_serialize(&ser), smt.root);
 }
 
@@ -320,7 +320,7 @@ fn test_set_hash_first_level() {
 
     assert_eq!(smt.root, hash_smt.root);
 
-    let ser = hash_smt.serialize();
+    let ser = hash_smt.to_vec();
     assert_eq!(hash_serialize(&ser), hash_smt.root);
 }
 
@@ -365,7 +365,7 @@ fn test_set_hash_order() {
 
     assert_eq!(smt.root, second_smt.root);
 
-    let ser = second_smt.serialize();
+    let ser = second_smt.to_vec();
     assert_eq!(hash_serialize(&ser), second_smt.root);
 }
 
@@ -379,7 +379,7 @@ fn test_serialize_and_prune() {
         smt.set(k, v);
     }
 
-    let ser = smt.serialize();
+    let ser = smt.to_vec();
     assert_eq!(hash_serialize(&ser), smt.root);
 
     let subset = {
@@ -391,13 +391,15 @@ fn test_serialize_and_prune() {
             .collect::<Vec<_>>()
     };
 
-    let pruned_ser = smt.serialize_and_prune(subset);
-    assert_eq!(hash_serialize(&pruned_ser), smt.root);
-    assert!(pruned_ser.len() <= ser.len());
+    let mut v = vec![U256::zero(), U256::zero()];
+    smt.serialize_and_prune(subset, &mut v, 0);
+    assert_eq!(hash_serialize(&v), smt.root);
+    assert!(v.len() <= ser.len());
 
-    let trivial_ser = smt.serialize_and_prune::<Key, Vec<_>>(vec![]);
+    let mut v = vec![U256::zero(), U256::zero()];
+    smt.serialize_and_prune::<Key, Vec<_>>(vec![], &mut v, 0);
     assert_eq!(
-        trivial_ser,
+        v,
         vec![
             U256::zero(),
             U256::zero(),
@@ -405,5 +407,5 @@ fn test_serialize_and_prune() {
             hashout2u(smt.root)
         ]
     );
-    assert_eq!(hash_serialize(&trivial_ser), smt.root);
+    assert_eq!(hash_serialize(&v), smt.root);
 }
diff --git a/trace_decoder/Cargo.toml b/trace_decoder/Cargo.toml
index da9394823..aa244c9d6 100644
--- a/trace_decoder/Cargo.toml
+++ b/trace_decoder/Cargo.toml
@@ -56,7 +56,6 @@ serde_path_to_error.workspace = true
 zero.workspace = true
 
 [features]
-default = ["eth_mainnet"]
 eth_mainnet = ["evm_arithmetization/eth_mainnet", "zero/eth_mainnet"]
 cdk_erigon = ["evm_arithmetization/cdk_erigon", "zero/cdk_erigon"]
 polygon_pos = ["evm_arithmetization/polygon_pos", "zero/polygon_pos"]
diff --git a/trace_decoder/src/core.rs b/trace_decoder/src/core.rs
index cd2bcfa6e..d263c47b2 100644
--- a/trace_decoder/src/core.rs
+++ b/trace_decoder/src/core.rs
@@ -12,7 +12,7 @@ use evm_arithmetization::{
     generation::TrieInputs,
     proof::{BlockMetadata, TrieRoots},
     tries::{MptKey, ReceiptTrie, StateMpt, StorageTrie, TransactionTrie},
-    world::{Hasher, KeccakHash, PoseidonHash, Type1World, Type2World, World},
+    world::{Hasher, KeccakHash, PoseidonHash, StateWorld, Type1World, Type2World, World},
     GenerationInputs,
 };
 use itertools::Itertools as _;
@@ -133,10 +133,6 @@ pub fn entrypoint(
                  after,
                  withdrawals,
              }| {
-                let (state, storage) = world
-                    .clone()
-                    .expect_left("TODO(0xaatif): evm_arithemetization accepts an SMT")
-                    .into_state_and_storage();
                 GenerationInputs {
                     txn_number_before: first_txn_ix.into(),
                     gas_used_before: running_gas_used.into(),
@@ -148,10 +144,11 @@ pub fn entrypoint(
                     withdrawals,
                     ger_data,
                     tries: TrieInputs {
-                        state_trie: state.into(),
+                        state_trie: StateWorld {
+                            state: world.clone(),
+                        },
                         transactions_trie: transaction.into(),
                         receipts_trie: receipt.into(),
-                        storage_tries: storage.into_iter().map(|(k, v)| (k, v.into())).collect(),
                     },
                     trie_roots_after: after,
                     checkpoint_state_trie_root,
@@ -207,7 +204,7 @@ fn start(
                                     path.into_hash()
                                         .context("invalid path length in direct state trie")?,
                                     rlp::decode(&bytes)
-                                        .context("invalid AccountRlp in direct state trie")?,
+                                        .context("invalid Account in direct state trie")?,
                                 )?;
                             }
                             mpt_trie::trie_ops::ValOrHash::Hash(h) => {
diff --git a/trace_decoder/src/lib.rs b/trace_decoder/src/lib.rs
index 4bd68bc11..160d48470 100644
--- a/trace_decoder/src/lib.rs
+++ b/trace_decoder/src/lib.rs
@@ -61,16 +61,14 @@
 const _DEVELOPER_DOCS: () = ();
 
 mod interface;
-
 pub use interface::*;
 
 mod type1;
 mod type2;
 mod wire;
 
-pub use core::{entrypoint, WireDisposition};
-
 mod core;
+pub use core::{entrypoint, WireDisposition};
 
 /// Implementation of the observer for the trace decoder.
 pub mod observer;
diff --git a/trace_decoder/src/type1.rs b/trace_decoder/src/type1.rs
index 2d9e293d5..20d71586e 100644
--- a/trace_decoder/src/type1.rs
+++ b/trace_decoder/src/type1.rs
@@ -6,7 +6,7 @@ use std::collections::{BTreeMap, BTreeSet};
 
 use anyhow::{bail, ensure, Context as _};
 use either::Either;
-use evm_arithmetization::generation::mpt::AccountRlp;
+use evm_arithmetization::generation::mpt::MptAccount;
 use evm_arithmetization::tries::{MptKey, StateMpt, StorageTrie};
 use evm_arithmetization::world::{Hasher as _, Type1World, World};
 use keccak_hash::H256;
@@ -69,7 +69,7 @@ fn visit(
                     storage,
                     code,
                 }) => {
-                    let account = AccountRlp {
+                    let account = MptAccount {
                         nonce: nonce.into(),
                         balance,
                         storage_root: {
diff --git a/trace_decoder/tests/consistent-with-header.rs b/trace_decoder/tests/consistent-with-header.rs
index 63df41b4f..9ff9d990b 100644
--- a/trace_decoder/tests/consistent-with-header.rs
+++ b/trace_decoder/tests/consistent-with-header.rs
@@ -7,9 +7,13 @@ mod common;
 use alloy_compat::Compat as _;
 use assert2::check;
 use common::{cases, Case};
+use either::Either;
+use ethereum_types::BigEndianHash;
 use itertools::Itertools;
+use keccak_hash::H256;
 use libtest_mimic::{Arguments, Trial};
 use mpt_trie::partial_trie::PartialTrie as _;
+use smt_trie::utils::hashout2u;
 use trace_decoder::observer::DummyObserver;
 use zero::prover::WIRE_DISPOSITION;
 
@@ -36,12 +40,24 @@ fn main() -> anyhow::Result<()> {
                 check!(gen_inputs.len() >= 2);
                 check!(
                     Some(other.checkpoint_state_trie_root)
-                        == gen_inputs.first().map(|it| it.tries.state_trie.hash())
+                        == gen_inputs
+                            .first()
+                            .map(|it| match &it.tries.state_trie.state {
+                                Either::Left(type1world) => type1world.state_trie().hash(),
+                                Either::Right(type2world) =>
+                                    H256::from_uint(&hashout2u(type2world.as_smt().root)),
+                            })
                 );
                 let pairs = || gen_inputs.iter().tuple_windows::<(_, _)>();
                 check!(
                     pairs().position(|(before, after)| {
-                        before.trie_roots_after.state_root != after.tries.state_trie.hash()
+                        let after_hash = match &after.tries.state_trie.state {
+                            Either::Left(type1world) => type1world.state_trie().hash(),
+                            Either::Right(type2world) => {
+                                H256::from_uint(&hashout2u(type2world.as_smt().root))
+                            }
+                        };
+                        before.trie_roots_after.state_root != after_hash
                     }) == None
                 );
                 check!(
diff --git a/trace_decoder/tests/simulate-execution.rs b/trace_decoder/tests/simulate-execution.rs
index fc7136c34..79613c45c 100644
--- a/trace_decoder/tests/simulate-execution.rs
+++ b/trace_decoder/tests/simulate-execution.rs
@@ -6,12 +6,14 @@ mod common;
 
 use anyhow::Context as _;
 use common::{cases, Case};
+use evm_arithmetization::testing_utils::init_logger;
 use libtest_mimic::{Arguments, Trial};
 use plonky2::field::goldilocks_field::GoldilocksField;
 use trace_decoder::observer::DummyObserver;
 use zero::prover::WIRE_DISPOSITION;
 
 fn main() -> anyhow::Result<()> {
+    init_logger();
     let mut trials = vec![];
     for batch_size in [1, 3] {
         for Case {
@@ -32,16 +34,18 @@ fn main() -> anyhow::Result<()> {
                 "error in `trace_decoder` for {name} at batch size {batch_size}"
             ))?;
             for (ix, gi) in gen_inputs.into_iter().enumerate() {
-                trials.push(Trial::test(
-                    format!("{name}@{batch_size}/{ix}"),
-                    move || {
-                        evm_arithmetization::prover::testing::simulate_execution_all_segments::<
+                if name == "b2841_dev" && batch_size == 1 && ix == 0 {
+                    trials.push(Trial::test(
+                        format!("{name}@{batch_size}/{ix}"),
+                        move || {
+                            evm_arithmetization::prover::testing::simulate_execution_all_segments::<
                             GoldilocksField,
                         >(gi, 19)
                         .map_err(|e| format!("{e:?}"))?; // get the full error chain
-                        Ok(())
-                    },
-                ))
+                            Ok(())
+                        },
+                    ))
+                }
             }
         }
     }
diff --git a/zero/src/trie_diff/mod.rs b/zero/src/trie_diff/mod.rs
index 088e2d835..e89240d9f 100644
--- a/zero/src/trie_diff/mod.rs
+++ b/zero/src/trie_diff/mod.rs
@@ -1,4 +1,4 @@
-use evm_arithmetization::generation::mpt::{AccountRlp, LegacyReceiptRlp};
+use evm_arithmetization::generation::mpt::{LegacyReceiptRlp, MptAccount};
 use evm_arithmetization::generation::DebugOutputTries;
 use mpt_trie::debug_tools::diff::{create_full_diff_between_tries, DiffPoint};
 use mpt_trie::utils::TrieNodeType;
@@ -85,7 +85,7 @@ pub fn compare_tries(
     }
 
     let state_trie_diff = create_full_diff_between_tries(&left.state_trie, &right.state_trie);
-    compare_tries_and_output_results::<usize, AccountRlp>(
+    compare_tries_and_output_results::<usize, MptAccount>(
         "state trie",
         state_trie_diff.diff_points,
         block_number,