From f7276a773bb6a6fe6d13ec3447b985961ca3e673 Mon Sep 17 00:00:00 2001
From: jjy <jjyruby@gmail.com>
Date: Mon, 31 Oct 2022 17:00:51 +0800
Subject: [PATCH 01/10] refactor: use layered StateDB to operate the state

---
 .../benches/benches/benchmarks/dummy_state.rs |  53 ++
 .../benches/benches/benchmarks/fee_queue.rs   |  15 +-
 crates/benches/benches/benchmarks/mod.rs      |   1 +
 crates/benches/benches/benchmarks/smt.rs      |  30 +-
 crates/benches/benches/benchmarks/sudt.rs     |   4 +-
 .../block-producer/src/block_sync_client.rs   |   4 +-
 crates/block-producer/src/produce_block.rs    |  14 +-
 crates/block-producer/src/replay_block.rs     |   9 +-
 crates/block-producer/src/sync_l1.rs          |   6 +-
 .../block-producer/src/test_mode_control.rs   |   2 +-
 crates/chain/src/chain.rs                     |  39 +-
 crates/challenge/src/context.rs               |  11 +-
 crates/challenge/src/offchain.rs              |  14 +-
 crates/challenge/src/offchain/mock_block.rs   |  30 +-
 crates/common/src/state.rs                    |   7 +-
 crates/generator/src/generator.rs             |  18 +-
 crates/generator/src/genesis.rs               |  16 +-
 crates/generator/src/lib.rs                   |   1 -
 .../generator/src/{ => tests}/dummy_state.rs  |   2 +-
 crates/generator/src/tests/genesis.rs         |  10 +-
 crates/generator/src/tests/mod.rs             |   1 +
 crates/generator/src/traits.rs                |  10 +-
 .../generator/src/types/run_result_state.rs   |   2 +-
 .../src/subcommand/db_block_validator.rs      |   4 +-
 .../src/subcommand/import_block.rs            |   2 +-
 crates/mem-pool/src/deposit.rs                |   6 +-
 crates/mem-pool/src/fee/queue.rs              |  55 +-
 crates/mem-pool/src/pool.rs                   | 142 ++--
 .../src/mem_execute_tx_state.rs               |   2 +-
 crates/replay-chain/src/replay.rs             |  11 +-
 crates/rpc-server/src/registry.rs             | 129 ++--
 crates/store/src/mem_pool_state.rs            | 240 +------
 crates/store/src/smt/smt_store/mod.rs         |   7 +
 .../{smt_store.rs => smt_store/smt_block.rs}  |  54 +-
 .../src/smt/smt_store/smt_reverted_block.rs   | 105 +++
 crates/store/src/smt/smt_store/smt_state.rs   | 116 ++++
 crates/store/src/snapshot.rs                  |  18 +-
 .../state/{ => history}/block_state_record.rs |   0
 .../store/src/state/history/history_state.rs  | 247 +++++++
 crates/store/src/state/history/mod.rs         |   2 +
 crates/store/src/state/mod.rs                 |  16 +-
 .../{mem_state_db.rs => overlay/mem_state.rs} |  80 ++-
 crates/store/src/state/overlay/mem_store.rs   | 161 +++++
 crates/store/src/state/overlay/mod.rs         |   2 +
 crates/store/src/state/state_db.rs            | 630 ++++++++++++++----
 crates/store/src/state/state_tracker.rs       |  39 --
 crates/store/src/state/traits.rs              |   5 +
 crates/store/src/store_impl.rs                |  20 +-
 crates/store/src/tests/state_db.rs            |  44 +-
 crates/store/src/tests/transaction.rs         |  32 +-
 .../store/src/transaction/code_store_impl.rs  |  30 +
 .../src/transaction/history_store_impl.rs     |  98 +++
 crates/store/src/transaction/mod.rs           |   2 +
 .../src/transaction/store_transaction.rs      | 169 +----
 crates/tests/src/testing_tool/chain.rs        |   2 +-
 crates/tests/src/tests/chain.rs               |  27 +-
 crates/tests/src/tests/deposit_withdrawal.rs  |  22 +-
 crates/tests/src/tests/export_import_block.rs |   2 +-
 crates/tests/src/tests/mem_block_repackage.rs |   7 +-
 crates/tests/src/tests/meta_contract_args.rs  |   8 +-
 .../src/tests/polyjuice_sender_recover.rs     |   9 +-
 crates/tests/src/tests/restore_mem_block.rs   |   5 +-
 .../tests/rpc_server/execute_l2transaction.rs |  41 +-
 .../block_max_cycles_limit.rs                 |  13 +-
 .../rpc_server/execute_raw_l2transaction.rs   |  56 +-
 .../block_max_cycles_limit.rs                 |  13 +-
 .../tests/rpc_server/submit_l2transaction.rs  |  63 +-
 .../block_max_cycles_limit.rs                 |  18 +-
 .../rpc_server/submit_withdrawal_request.rs   |   6 +-
 .../polyjuice_contract_creator_allowlist.rs   |   2 +-
 crates/utils/src/export_block.rs              |   5 +-
 71 files changed, 1939 insertions(+), 1127 deletions(-)
 create mode 100644 crates/benches/benches/benchmarks/dummy_state.rs
 rename crates/generator/src/{ => tests}/dummy_state.rs (99%)
 create mode 100644 crates/store/src/smt/smt_store/mod.rs
 rename crates/store/src/smt/{smt_store.rs => smt_store/smt_block.rs} (60%)
 create mode 100644 crates/store/src/smt/smt_store/smt_reverted_block.rs
 create mode 100644 crates/store/src/smt/smt_store/smt_state.rs
 rename crates/store/src/state/{ => history}/block_state_record.rs (100%)
 create mode 100644 crates/store/src/state/history/history_state.rs
 create mode 100644 crates/store/src/state/history/mod.rs
 rename crates/store/src/state/{mem_state_db.rs => overlay/mem_state.rs} (56%)
 create mode 100644 crates/store/src/state/overlay/mem_store.rs
 create mode 100644 crates/store/src/state/overlay/mod.rs
 delete mode 100644 crates/store/src/state/state_tracker.rs
 create mode 100644 crates/store/src/state/traits.rs
 create mode 100644 crates/store/src/transaction/code_store_impl.rs
 create mode 100644 crates/store/src/transaction/history_store_impl.rs

diff --git a/crates/benches/benches/benchmarks/dummy_state.rs b/crates/benches/benches/benchmarks/dummy_state.rs
new file mode 100644
index 000000000..229621638
--- /dev/null
+++ b/crates/benches/benches/benchmarks/dummy_state.rs
@@ -0,0 +1,53 @@
+use gw_common::{
+    error::Error,
+    smt::{default_store::DefaultStore, H256, SMT},
+    state::State,
+};
+use gw_traits::CodeStore;
+use gw_types::{bytes::Bytes, packed::Script};
+use std::collections::HashMap;
+
+#[derive(Default)]
+pub struct DummyState {
+    tree: SMT<DefaultStore<H256>>,
+    account_count: u32,
+    scripts: HashMap<H256, Script>,
+    codes: HashMap<H256, Bytes>,
+}
+
+impl State for DummyState {
+    fn get_raw(&self, key: &H256) -> Result<H256, Error> {
+        let v = self.tree.get(key)?;
+        Ok(v)
+    }
+    fn update_raw(&mut self, key: H256, value: H256) -> Result<(), Error> {
+        self.tree.update(key, value)?;
+        Ok(())
+    }
+    fn finalise_root(&mut self) -> Result<H256, Error> {
+        let root = *self.tree.root();
+        Ok(root)
+    }
+    fn get_account_count(&self) -> Result<u32, Error> {
+        Ok(self.account_count)
+    }
+    fn set_account_count(&mut self, count: u32) -> Result<(), Error> {
+        self.account_count = count;
+        Ok(())
+    }
+}
+
+impl CodeStore for DummyState {
+    fn insert_script(&mut self, script_hash: H256, script: Script) {
+        self.scripts.insert(script_hash, script);
+    }
+    fn get_script(&self, script_hash: &H256) -> Option<Script> {
+        self.scripts.get(script_hash).cloned()
+    }
+    fn insert_data(&mut self, data_hash: H256, code: Bytes) {
+        self.codes.insert(data_hash, code);
+    }
+    fn get_data(&self, script_hash: &H256) -> Option<Bytes> {
+        self.codes.get(script_hash).cloned()
+    }
+}
diff --git a/crates/benches/benches/benchmarks/fee_queue.rs b/crates/benches/benches/benchmarks/fee_queue.rs
index 7e14ff424..a97e15984 100644
--- a/crates/benches/benches/benchmarks/fee_queue.rs
+++ b/crates/benches/benches/benchmarks/fee_queue.rs
@@ -7,7 +7,9 @@ use gw_mem_pool::fee::{
     types::{FeeEntry, FeeItem, FeeItemSender},
 };
 use gw_store::{
-    mem_pool_state::MemStore, state::state_db::StateContext, traits::chain_store::ChainStore, Store,
+    state::{history::history_state::RWConfig, BlockStateDB, MemStateDB},
+    traits::chain_store::ChainStore,
+    Store,
 };
 use gw_types::{
     bytes::Bytes,
@@ -23,10 +25,10 @@ fn bench_add_full(b: &mut Bencher) {
     let store = Store::open_tmp().expect("open store");
     setup_genesis(&store);
     {
-        let db = store.begin_transaction();
+        let db = &store.begin_transaction();
         let genesis = db.get_tip_block().expect("tip");
         assert_eq!(genesis.raw().number().unpack(), 0);
-        let mut state = db.state_tree(StateContext::AttachBlock(1)).expect("state");
+        let mut state = BlockStateDB::from_store(db, RWConfig::attach_block(1)).unwrap();
 
         // create accounts
         for i in 0..4 {
@@ -79,10 +81,10 @@ fn bench_add_fetch_20(b: &mut Bencher) {
     let store = Store::open_tmp().expect("open store");
     setup_genesis(&store);
     {
-        let db = store.begin_transaction();
+        let db = &store.begin_transaction();
         let genesis = db.get_tip_block().expect("tip");
         assert_eq!(genesis.raw().number().unpack(), 0);
-        let mut state = db.state_tree(StateContext::AttachBlock(1)).expect("state");
+        let mut state = BlockStateDB::from_store(db, RWConfig::attach_block(1)).unwrap();
 
         // create accounts
         for i in 0..4 {
@@ -108,8 +110,7 @@ fn bench_add_fetch_20(b: &mut Bencher) {
         queue.add(entry1, ());
     }
 
-    let mem_store = MemStore::new(snap);
-    let tree = mem_store.state().unwrap();
+    let tree = MemStateDB::from_store(snap).unwrap();
 
     b.iter(|| {
         for i in 0..20 {
diff --git a/crates/benches/benches/benchmarks/mod.rs b/crates/benches/benches/benchmarks/mod.rs
index 4d0e03bcc..8b1adca01 100644
--- a/crates/benches/benches/benchmarks/mod.rs
+++ b/crates/benches/benches/benchmarks/mod.rs
@@ -1,3 +1,4 @@
+mod dummy_state;
 pub mod fee_queue;
 pub mod init_db;
 pub mod smt;
diff --git a/crates/benches/benches/benchmarks/smt.rs b/crates/benches/benches/benchmarks/smt.rs
index cdddcd3eb..32059c697 100644
--- a/crates/benches/benches/benchmarks/smt.rs
+++ b/crates/benches/benches/benchmarks/smt.rs
@@ -19,8 +19,12 @@ use gw_generator::{
     Generator,
 };
 use gw_store::{
-    mem_pool_state::{MemPoolState, MemStore},
-    state::state_db::{StateContext, StateTree},
+    mem_pool_state::MemPoolState,
+    state::{
+        history::history_state::{HistoryState, RWConfig},
+        state_db::StateDB,
+        MemStateDB,
+    },
     traits::chain_store::ChainStore,
     Store,
 };
@@ -182,7 +186,10 @@ impl BenchExecutionEnvironment {
         );
 
         Self::init_genesis(&store, &genesis_config, accounts);
-        let mem_pool_state = MemPoolState::new(Arc::new(MemStore::new(store.get_snapshot())), true);
+        let mem_pool_state = MemPoolState::new(
+            MemStateDB::from_store(store.get_snapshot()).expect("mem state db"),
+            true,
+        );
 
         BenchExecutionEnvironment {
             generator,
@@ -192,8 +199,7 @@ impl BenchExecutionEnvironment {
     }
 
     fn accounts_transfer(&self, accounts: u32, count: usize) {
-        let snap = self.mem_pool_state.load();
-        let mut state = snap.state().unwrap();
+        let mut state = self.mem_pool_state.load_state_db();
 
         let (block_producer_script, block_producer) = Account::build_script(0);
         let block_info = BlockInfo::new_builder()
@@ -271,10 +277,9 @@ impl BenchExecutionEnvironment {
             }
             transfer_count -= 1;
         }
-        self.mem_pool_state.store(snap.into());
+        self.mem_pool_state.store_state_db(state);
 
-        let snap = self.mem_pool_state.load();
-        let state = snap.state().unwrap();
+        let state = self.mem_pool_state.load_state_db();
         let post_block_producer_balance = state
             .get_sudt_balance(CKB_SUDT_ACCOUNT_ID, &block_producer)
             .unwrap();
@@ -322,10 +327,13 @@ impl BenchExecutionEnvironment {
         let (db, genesis_state) = build_genesis_from_store(db, config, Default::default()).unwrap();
 
         let smt = db
-            .account_smt_with_merkle_state(genesis_state.genesis.raw().post_account())
+            .state_smt_with_merkle_state(genesis_state.genesis.raw().post_account())
             .unwrap();
         let account_count = genesis_state.genesis.raw().post_account().count().unpack();
-        let mut state = { StateTree::new(smt, account_count, StateContext::AttachBlock(0)) };
+        let mut state = {
+            let history_state = HistoryState::new(smt, account_count, RWConfig::attach_block(0));
+            StateDB::new(history_state)
+        };
 
         Self::generate_accounts(&mut state, accounts + 1); // Plus block producer
 
@@ -338,7 +346,7 @@ impl BenchExecutionEnvironment {
 
             // calculate post state
             let post_account = {
-                let root = state.calculate_root().unwrap();
+                let root = state.finalise_root().unwrap();
                 let count = state.get_account_count().unwrap();
                 AccountMerkleState::new_builder()
                     .merkle_root(root.pack())
diff --git a/crates/benches/benches/benchmarks/sudt.rs b/crates/benches/benches/benchmarks/sudt.rs
index e95d84b19..a8f3b3877 100644
--- a/crates/benches/benches/benchmarks/sudt.rs
+++ b/crates/benches/benches/benchmarks/sudt.rs
@@ -1,3 +1,4 @@
+use super::dummy_state::DummyState;
 use criterion::*;
 use gw_common::{
     builtins::ETH_REGISTRY_ACCOUNT_ID, registry_address::RegistryAddress, state::State, H256,
@@ -5,8 +6,7 @@ use gw_common::{
 use gw_config::{BackendConfig, BackendSwitchConfig};
 use gw_generator::{
     account_lock_manage::AccountLockManage, backend_manage::BackendManage,
-    constants::L2TX_MAX_CYCLES, dummy_state::DummyState, error::TransactionError, traits::StateExt,
-    Generator,
+    constants::L2TX_MAX_CYCLES, error::TransactionError, traits::StateExt, Generator,
 };
 use gw_traits::{ChainView, CodeStore};
 use gw_types::{
diff --git a/crates/block-producer/src/block_sync_client.rs b/crates/block-producer/src/block_sync_client.rs
index 0b646da8b..c34b31595 100644
--- a/crates/block-producer/src/block_sync_client.rs
+++ b/crates/block-producer/src/block_sync_client.rs
@@ -326,12 +326,12 @@ async fn handle_local_block(
         "received block {block_number} {}",
         ckb_types::H256::from(block_hash),
     );
-    let store_tx = client.store.begin_transaction();
+    let store_tx = &client.store.begin_transaction();
     let store_block_hash = store_tx.get_block_hash_by_number(block_number)?;
     if let Some(store_block_hash) = store_block_hash {
         if store_block_hash != block_hash.into() {
             log::info!("revert to {}", block_number - 1);
-            revert(client, &store_tx, block_number - 1).await?;
+            revert(client, store_tx, block_number - 1).await?;
             store_tx.commit()?;
         } else {
             log::info!("block already known");
diff --git a/crates/block-producer/src/produce_block.rs b/crates/block-producer/src/produce_block.rs
index 0b88c6643..7b0bae58f 100644
--- a/crates/block-producer/src/produce_block.rs
+++ b/crates/block-producer/src/produce_block.rs
@@ -14,7 +14,9 @@ use gw_common::{
 use gw_generator::Generator;
 use gw_mem_pool::mem_block::MemBlock;
 use gw_store::{
-    state::state_db::StateContext, traits::chain_store::ChainStore, transaction::StoreTransaction,
+    state::{history::history_state::RWConfig, BlockStateDB},
+    traits::chain_store::ChainStore,
+    transaction::StoreTransaction,
     Store,
 };
 use gw_types::{
@@ -184,7 +186,7 @@ pub fn generate_produce_block_param(
     mem_block: MemBlock,
     post_merkle_state: AccountMerkleState,
 ) -> Result<BlockParam> {
-    let db = store.begin_transaction();
+    let db = &store.begin_transaction();
     let tip_block_number = mem_block.block_info().number().unpack().saturating_sub(1);
     let tip_block_hash = {
         let opt = db.get_block_hash_by_number(tip_block_number)?;
@@ -192,7 +194,7 @@ pub fn generate_produce_block_param(
     };
 
     // generate kv state & merkle proof from tip state
-    let chain_state = db.state_tree(StateContext::ReadOnly)?;
+    let chain_state = BlockStateDB::from_store(db, RWConfig::readonly())?;
 
     let kv_state: Vec<(H256, H256)> = mem_block
         .touched_keys()
@@ -208,9 +210,9 @@ pub fn generate_produce_block_param(
         // nothing need to prove
         Vec::new()
     } else {
-        let account_smt = db.account_smt()?;
+        let state_smt = db.state_smt()?;
 
-        account_smt
+        state_smt
             .merkle_proof(kv_state.iter().map(|(k, _v)| *k).collect())
             .map_err(|err| anyhow!("merkle proof error: {:?}", err))?
             .compile(kv_state.clone())?
@@ -263,7 +265,7 @@ pub fn generate_produce_block_param(
 
         // check smt root
         let expected_kv_state_root: H256 = prev_merkle_state.merkle_root().unpack();
-        let smt = db.account_smt()?;
+        let smt = db.state_smt()?;
         assert_eq!(
             smt.root(),
             &expected_kv_state_root,
diff --git a/crates/block-producer/src/replay_block.rs b/crates/block-producer/src/replay_block.rs
index fa411400f..6bbf929c2 100644
--- a/crates/block-producer/src/replay_block.rs
+++ b/crates/block-producer/src/replay_block.rs
@@ -8,7 +8,7 @@ use gw_generator::constants::L2TX_MAX_CYCLES;
 use gw_generator::traits::StateExt;
 use gw_generator::Generator;
 use gw_store::chain_view::ChainView;
-use gw_store::mem_pool_state::MemStore;
+use gw_store::state::MemStateDB;
 use gw_store::traits::chain_store::ChainStore;
 use gw_store::Store;
 use gw_types::packed::{BlockInfo, DepositRequest, L2Block, RawL2Block, WithdrawalRequestExtra};
@@ -35,13 +35,12 @@ impl ReplayBlock {
             .get_block(&parent_block_hash)?
             .ok_or_else(|| anyhow!("replay parent block not found"))?;
 
-        let mem_store = MemStore::new(snap);
-        let mut state = mem_store.state()?;
+        let mut state = MemStateDB::from_store(snap)?;
         {
             let parent_post_state = parent_block.raw().post_account();
             assert_eq!(
                 parent_post_state,
-                state.merkle_state()?,
+                state.finalise_merkle_state()?,
                 "merkle state should equals to parent block"
             );
         };
@@ -88,7 +87,7 @@ impl ReplayBlock {
         }
 
         // handle transactions
-        let db = store.begin_transaction();
+        let db = &store.begin_transaction();
         let chain_view = ChainView::new(&db, parent_block_hash);
         for (tx_index, tx) in block.transactions().into_iter().enumerate() {
             generator.check_transaction_signature(&state, &tx)?;
diff --git a/crates/block-producer/src/sync_l1.rs b/crates/block-producer/src/sync_l1.rs
index 0d48e3f8c..701a05d5d 100644
--- a/crates/block-producer/src/sync_l1.rs
+++ b/crates/block-producer/src/sync_l1.rs
@@ -51,7 +51,7 @@ pub async fn sync_l1(ctx: &(dyn SyncL1Context + Sync + Send)) -> Result<()> {
 
 async fn sync_l1_impl(ctx: &(dyn SyncL1Context + Sync + Send)) -> Result<()> {
     log::info!("syncing with L1");
-    let store_tx = ctx.store().begin_transaction();
+    let store_tx = &ctx.store().begin_transaction();
     let last_confirmed_local = store_tx
         .get_last_confirmed_block_number_hash()
         .context("get last confirmed")?;
@@ -86,7 +86,7 @@ async fn sync_l1_impl(ctx: &(dyn SyncL1Context + Sync + Send)) -> Result<()> {
 // accidentally running two godwoken full nodes.
 async fn sync_l1_unknown(
     ctx: &(dyn SyncL1Context + Send + Sync),
-    store_tx: StoreTransaction,
+    store_tx: &StoreTransaction,
     mut last_confirmed: u64,
 ) -> Result<()> {
     log::info!("syncing unknown L2 blocks from L1");
@@ -150,7 +150,7 @@ async fn sync_l1_unknown(
                 }
 
                 log::info!("L2 fork detected, reverting to L2 block {last_confirmed}");
-                revert(ctx, &store_tx, last_confirmed).await?;
+                revert(ctx, store_tx, last_confirmed).await?;
                 // Commit transaction because chain_updater.update_single will open and commit new transactions.
                 store_tx.commit()?;
                 reverted = true;
diff --git a/crates/block-producer/src/test_mode_control.rs b/crates/block-producer/src/test_mode_control.rs
index fde46db61..c6e1587db 100644
--- a/crates/block-producer/src/test_mode_control.rs
+++ b/crates/block-producer/src/test_mode_control.rs
@@ -251,7 +251,7 @@ impl TestModeControl {
             (block_number, target_index, target_type)
         };
 
-        let db = self.store.begin_transaction();
+        let db = &self.store.begin_transaction();
         let block_hash = db.get_block_hash_by_number(block_number)?;
         let block =
             db.get_block(&block_hash.ok_or_else(|| anyhow!("block {} not found", block_number))?)?;
diff --git a/crates/chain/src/chain.rs b/crates/chain/src/chain.rs
index c89300b63..6be974873 100644
--- a/crates/chain/src/chain.rs
+++ b/crates/chain/src/chain.rs
@@ -13,8 +13,11 @@ use gw_generator::{
 use gw_jsonrpc_types::debugger::ReprMockTransaction;
 use gw_mem_pool::pool::MemPool;
 use gw_store::{
-    chain_view::ChainView, state::state_db::StateContext, traits::chain_store::ChainStore,
-    transaction::StoreTransaction, Store,
+    chain_view::ChainView,
+    state::{history::history_state::RWConfig, BlockStateDB},
+    traits::chain_store::ChainStore,
+    transaction::StoreTransaction,
+    Store,
 };
 use gw_types::{
     bytes::Bytes,
@@ -241,10 +244,10 @@ impl Chain {
         offchain_mock_context: &OffChainMockContext,
         target: ChallengeTarget,
     ) -> Result<ReprMockTransaction> {
-        let db = self.store().begin_transaction();
+        let db = &self.store().begin_transaction();
 
         let verify_context =
-            gw_challenge::context::build_verify_context(Arc::clone(&self.generator), &db, &target)
+            gw_challenge::context::build_verify_context(Arc::clone(&self.generator), db, &target)
                 .with_context(|| "dump cancel challenge tx from chain")?;
 
         let global_state = {
@@ -677,10 +680,8 @@ impl Chain {
                     db.detach_block(&l2block)?;
                     // detach block state from state tree
                     {
-                        let mut tree = db.state_tree(StateContext::DetachBlock(
-                            l2block.raw().number().unpack(),
-                        ))?;
-                        tree.detach_block_state()?;
+                        let mut tree = BlockStateDB::from_store(db, RWConfig::detach_block())?;
+                        tree.detach_block_state(l2block.raw().number().unpack())?;
                     }
 
                     // Check local tip block
@@ -728,10 +729,10 @@ impl Chain {
 
                     // Check current state
                     let expected_state = l2block.raw().prev_account();
-                    let tree = db.state_tree(StateContext::ReadOnly)?;
+                    let mut tree = BlockStateDB::from_store(db, RWConfig::readonly())?;
                     let expected_root: H256 = expected_state.merkle_root().unpack();
                     let expected_count: u32 = expected_state.count().unpack();
-                    assert_eq!(tree.calculate_root()?, expected_root);
+                    assert_eq!(tree.finalise_root()?, expected_root);
                     assert_eq!(tree.get_account_count()?, expected_count);
 
                     // Check genesis state still consistent
@@ -834,13 +835,13 @@ impl Chain {
 
     /// Sync chain from layer1
     pub async fn sync(&mut self, param: SyncParam) -> Result<()> {
-        let db = self.store.begin_transaction();
+        let db = &self.store.begin_transaction();
         let is_l1_revert_happend = !param.reverts.is_empty();
         // revert layer1 actions
         if !param.reverts.is_empty() {
             // revert
             for reverted_action in param.reverts {
-                self.revert_l1action(&db, reverted_action)?;
+                self.revert_l1action(db, reverted_action)?;
             }
         }
         let has_bad_block_before_update = self.challenge_target.is_some();
@@ -851,7 +852,7 @@ impl Chain {
         log::debug!(target: "sync-block", "sync {} actions", updates.len());
         for (i, action) in updates.into_iter().enumerate() {
             let t = Instant::now();
-            self.update_l1action(&db, action)?;
+            self.update_l1action(db, action)?;
             log::debug!(target: "sync-block", "process {}th action cost {}ms", i, t.elapsed().as_millis());
             match self.last_sync_event() {
                 SyncEvent::Success => (),
@@ -890,13 +891,13 @@ impl Chain {
         };
 
         assert_eq!(
-            db.account_smt().unwrap().root(),
+            db.state_smt().unwrap().root(),
             &expected_account.merkle_root().unpack(),
             "account root consistent in DB"
         );
 
-        let tree = db.state_tree(StateContext::ReadOnly)?;
-        let current_account = tree.merkle_state()?;
+        let mut tree = BlockStateDB::from_store(db, RWConfig::readonly())?;
+        let current_account = tree.finalise_merkle_state()?;
 
         assert_eq!(
             current_account.as_slice(),
@@ -997,14 +998,14 @@ impl Chain {
             withdrawals: withdrawals.clone(),
         };
         let tip_block_hash = self.local_state.tip().hash().into();
-        let chain_view = ChainView::new(db, tip_block_hash);
+        let chain_view = ChainView::new(&db, tip_block_hash);
 
         {
-            let tree = db.state_tree(StateContext::ReadOnly)?;
+            let mut tree = BlockStateDB::from_store(db, RWConfig::readonly())?;
 
             let prev_merkle_state = l2block.raw().prev_account();
             assert_eq!(
-                tree.merkle_state()?.as_slice(),
+                tree.finalise_merkle_state()?.as_slice(),
                 prev_merkle_state.as_slice(),
                 "prev account merkle state must be consistent"
             );
diff --git a/crates/challenge/src/context.rs b/crates/challenge/src/context.rs
index 1e0a147f7..1793abc6c 100644
--- a/crates/challenge/src/context.rs
+++ b/crates/challenge/src/context.rs
@@ -13,8 +13,8 @@ use gw_generator::constants::L2TX_MAX_CYCLES;
 use gw_generator::traits::StateExt;
 use gw_generator::{types::vm::ChallengeContext, Generator};
 use gw_store::chain_view::ChainView;
-use gw_store::state::mem_state_db::MemStateTree;
-use gw_store::state::state_db::StateContext;
+use gw_store::state::history::history_state::{RWConfig, ReadOpt, WriteOpt};
+use gw_store::state::{BlockStateDB, MemStateDB};
 use gw_store::traits::chain_store::ChainStore;
 use gw_store::transaction::StoreTransaction;
 use gw_traits::CodeStore;
@@ -170,9 +170,8 @@ fn build_verify_withdrawal_witness(
     let sender_script_hash: [u8; 32] = withdrawal.raw().account_script_hash().unpack();
     let sender_script = {
         let raw_block = block.raw();
-        let tree = db.state_tree(StateContext::ReadOnlyHistory(
-            raw_block.number().unpack() - 1,
-        ))?;
+        let tree =
+            BlockStateDB::from_store(db, RWConfig::history_block(raw_block.number().unpack() - 1))?;
         tree.get_script(&sender_script_hash.into())
             .ok_or_else(|| anyhow!("sender script not found"))?
     };
@@ -333,7 +332,7 @@ fn build_tx_kv_witness(
 
     // FIXME we need execute block until challenge point
 
-    let mut tree: MemStateTree<'_> = unimplemented!("fetch tx_index state");
+    let mut tree: MemStateDB = unimplemented!("fetch tx_index state");
     // let prev_tx_account_count = tree.get_account_count()?;
 
     // // Check prev tx account state
diff --git a/crates/challenge/src/offchain.rs b/crates/challenge/src/offchain.rs
index 99b89ac34..03768df42 100644
--- a/crates/challenge/src/offchain.rs
+++ b/crates/challenge/src/offchain.rs
@@ -9,7 +9,7 @@ use gw_common::H256;
 use gw_config::{BlockProducerConfig, DebugConfig, OffChainValidatorConfig};
 use gw_rpc_client::contract::ContractsCellDepManager;
 use gw_rpc_client::rpc_client::RPCClient;
-use gw_store::state::mem_state_db::MemStateTree;
+use gw_store::state::MemStateDB;
 use gw_store::transaction::StoreTransaction;
 use gw_types::core::DepType;
 use gw_types::offchain::{CellInfo, InputCellInfo, RollupContext, RunResult};
@@ -46,7 +46,7 @@ const MARGIN_OF_MOCK_BLOCK_SAFITY_CYCLES: u64 = 5_000_000;
 const MARGIN_OF_MOCK_BLOCK_SAFITY_TX_SIZE_LIMIT: u64 =
     MAX_BLOCK_BYTES - MAX_TX_WITHDRAWAL_PROOF_SIZE;
 
-type MemTree<'a> = MemStateTree<'a>;
+type MemTree = MemStateDB;
 
 #[derive(Debug, Clone)]
 pub struct CKBGenesisInfo {
@@ -241,7 +241,7 @@ impl OffChainCancelChallengeValidator {
     pub fn verify_withdrawal_request(
         &mut self,
         db: &StoreTransaction,
-        mem_tree: &mut MemTree<'_>,
+        mem_tree: &mut MemTree,
         req: WithdrawalRequestExtra,
     ) -> Result<Option<u64>> {
         let block_param = &mut self.block_param;
@@ -317,7 +317,7 @@ impl OffChainCancelChallengeValidator {
     pub fn verify_transaction(
         &mut self,
         db: &StoreTransaction,
-        mem_tree: &mut MemTree<'_>,
+        mem_tree: &mut MemTree,
         tx: L2Transaction,
         run_result: &RunResult,
     ) -> Result<Option<VerifyTxCycles>> {
@@ -334,7 +334,7 @@ impl OffChainCancelChallengeValidator {
         let verify_signature = |tx_with_context: &mut Option<TxWithContext>,
                                 safe_margin: &mut MarginOfMockBlockSafity,
                                 raw_block_flag: &mut RawBlockFlag,
-                                mem_tree: &mut MemTree<'_>|
+                                mem_tree: &mut MemTree|
          -> Result<_> {
             let challenge = block_param.challenge_last_tx_signature(db, mem_tree)?;
             let mock_output = mock_tx::mock_cancel_challenge_tx(
@@ -369,7 +369,7 @@ impl OffChainCancelChallengeValidator {
                                 safe_margin: &mut MarginOfMockBlockSafity,
                                 raw_block_flag: &mut RawBlockFlag,
                                 load_data_strategy: LoadDataStrategy,
-                                mem_tree: &mut MemTree<'_>|
+                                mem_tree: &mut MemTree|
          -> Result<_> {
             let challenge = block_param.challenge_last_tx_execution(db, mem_tree, run_result)?;
             let mock_output = mock_tx::mock_cancel_challenge_tx(
@@ -414,7 +414,7 @@ impl OffChainCancelChallengeValidator {
             execution_by_celldep: None,
         };
 
-        let verify = |mem_tree: &mut MemTree<'_>| -> Result<_> {
+        let verify = |mem_tree: &mut MemTree| -> Result<_> {
             if validator_config.verify_tx_signature {
                 cycles.signature = verify_signature(
                     &mut tx_with_context,
diff --git a/crates/challenge/src/offchain/mock_block.rs b/crates/challenge/src/offchain/mock_block.rs
index c1815cd57..189b8d8f4 100644
--- a/crates/challenge/src/offchain/mock_block.rs
+++ b/crates/challenge/src/offchain/mock_block.rs
@@ -14,7 +14,7 @@ use gw_common::state::{
 };
 use gw_common::H256;
 use gw_generator::traits::StateExt;
-use gw_store::state::mem_state_db::MemStateTree;
+use gw_store::state::MemStateDB;
 use gw_store::transaction::StoreTransaction;
 use gw_traits::CodeStore;
 use gw_types::core::{ChallengeTargetType, Status};
@@ -29,7 +29,7 @@ use gw_types::prelude::*;
 
 use std::collections::HashMap;
 
-type MemTree<'a> = MemStateTree<'a>;
+type MemTree = MemStateDB;
 
 #[derive(thiserror::Error, Debug)]
 #[error("{:?}", {0})]
@@ -98,7 +98,7 @@ impl MockBlockParam {
 
     pub fn push_withdrawal_request(
         &mut self,
-        mem_tree: &mut MemTree<'_>,
+        mem_tree: &mut MemTree,
         req: WithdrawalRequestExtra,
     ) -> Result<()> {
         if self.withdrawals.contains(&req) {
@@ -110,7 +110,7 @@ impl MockBlockParam {
             &self.block_producer,
             &req.request(),
         )?;
-        let post_account = mem_tree.merkle_state()?;
+        let post_account = mem_tree.finalise_merkle_state()?;
         let checkpoint = calculate_state_checkpoint(
             &post_account.merkle_root().unpack(),
             post_account.count().unpack(),
@@ -129,7 +129,7 @@ impl MockBlockParam {
 
     pub fn push_transaction(
         &mut self,
-        mem_tree: &mut MemTree<'_>,
+        mem_tree: &mut MemTree,
         tx: L2Transaction,
         run_result: &RunResult,
     ) -> Result<()> {
@@ -139,7 +139,7 @@ impl MockBlockParam {
 
         if self.transactions.inner.is_empty() {
             let checkpoint = {
-                let prev_txs_state = mem_tree.get_merkle_state();
+                let prev_txs_state = mem_tree.finalise_merkle_state()?;
                 calculate_state_checkpoint(
                     &prev_txs_state.merkle_root().unpack(),
                     prev_txs_state.count().unpack(),
@@ -150,7 +150,7 @@ impl MockBlockParam {
         }
 
         mem_tree.apply_run_result(&run_result.write)?;
-        let post_account = mem_tree.merkle_state()?;
+        let post_account = mem_tree.finalise_merkle_state()?;
         let checkpoint = calculate_state_checkpoint(
             &post_account.merkle_root().unpack(),
             post_account.count().unpack(),
@@ -173,7 +173,7 @@ impl MockBlockParam {
     pub fn challenge_last_withdrawal(
         &self,
         db: &StoreTransaction,
-        mem_tree: &mut MemTree<'_>,
+        mem_tree: &mut MemTree,
     ) -> Result<MockChallengeOutput> {
         let target_index = self.withdrawals.inner.len().saturating_sub(1);
         let target_type = ChallengeTargetType::Withdrawal as u8;
@@ -212,7 +212,7 @@ impl MockBlockParam {
     pub fn challenge_last_tx_signature(
         &self,
         db: &StoreTransaction,
-        mem_tree: &mut MemTree<'_>,
+        mem_tree: &mut MemTree,
     ) -> Result<MockChallengeOutput> {
         let target_index = self.transactions.inner.len().saturating_sub(1);
         let target_type = ChallengeTargetType::TxSignature as u8;
@@ -246,7 +246,7 @@ impl MockBlockParam {
     pub fn challenge_last_tx_execution(
         &self,
         db: &StoreTransaction,
-        mem_tree: &mut MemTree<'_>,
+        mem_tree: &mut MemTree,
         run_result: &RunResult,
     ) -> Result<MockChallengeOutput> {
         let target_index = self.transactions.inner.len().saturating_sub(1);
@@ -376,7 +376,7 @@ impl MockBlockParam {
 
     fn build_transaction_signature_verify_context(
         &self,
-        mem_tree: &mut MemTree<'_>,
+        mem_tree: &mut MemTree,
         tx: L2Transaction,
         raw_block: RawL2Block,
     ) -> Result<VerifyContext> {
@@ -407,7 +407,7 @@ impl MockBlockParam {
 
         let touched_keys = kv_state.iter().map(|(key, _)| key.to_owned()).collect();
         let kv_state_proof = {
-            let smt = mem_tree.smt();
+            let smt = mem_tree.inner_smt_tree();
             smt.merkle_proof(touched_keys)?.compile(kv_state.clone())?
         };
 
@@ -438,7 +438,7 @@ impl MockBlockParam {
 
     fn build_transaction_execution_verify_context(
         &self,
-        mem_tree: &mut MemTree<'_>,
+        mem_tree: &mut MemTree,
         tx: L2Transaction,
         raw_block: RawL2Block,
         run_result: &RunResult,
@@ -488,7 +488,7 @@ impl MockBlockParam {
         let touched_keys = kv_state.iter().map(|(key, _)| key.to_owned()).collect();
         let kv_state: Vec<(H256, H256)> = kv_state.into_iter().collect();
         let kv_state_proof = {
-            let smt = mem_tree.smt();
+            let smt = mem_tree.inner_smt_tree();
             smt.merkle_proof(touched_keys)?.compile(kv_state.clone())?
         };
 
@@ -671,7 +671,7 @@ impl RawBlockTransactions {
     }
 }
 
-fn get_script(state: &MemStateTree<'_>, account_id: u32) -> Result<Script> {
+fn get_script(state: &MemTree, account_id: u32) -> Result<Script> {
     let script_hash = state.get_script_hash(account_id)?;
     state
         .get_script(&script_hash)
diff --git a/crates/common/src/state.rs b/crates/common/src/state.rs
index 82ce0b0b7..18910d6cb 100644
--- a/crates/common/src/state.rs
+++ b/crates/common/src/state.rs
@@ -131,7 +131,8 @@ pub trait State {
     fn update_raw(&mut self, key: H256, value: H256) -> Result<(), Error>;
     fn get_account_count(&self) -> Result<u32, Error>;
     fn set_account_count(&mut self, count: u32) -> Result<(), Error>;
-    fn calculate_root(&self) -> Result<H256, Error>;
+    // Refresh dirty state and return current root
+    fn finalise_root(&mut self) -> Result<H256, Error>;
 
     // implementations
     fn get_value(&self, id: u32, key: &[u8]) -> Result<H256, Error> {
@@ -277,8 +278,8 @@ pub trait State {
     }
 
     /// calculate state checkpoint
-    fn calculate_state_checkpoint(&self) -> Result<H256, Error> {
-        let account_root = self.calculate_root()?;
+    fn calculate_state_checkpoint(&mut self) -> Result<H256, Error> {
+        let account_root = self.finalise_root()?;
         let account_count = self.get_account_count()?;
         Ok(calculate_state_checkpoint(&account_root, account_count))
     }
diff --git a/crates/generator/src/generator.rs b/crates/generator/src/generator.rs
index 2197a44e9..16ff7c42a 100644
--- a/crates/generator/src/generator.rs
+++ b/crates/generator/src/generator.rs
@@ -36,7 +36,10 @@ use gw_common::{
 };
 
 use gw_config::{ContractLogConfig, SyscallCyclesConfig};
-use gw_store::{state::state_db::StateContext, transaction::StoreTransaction};
+use gw_store::{
+    state::{history::history_state::RWConfig, BlockStateDB},
+    transaction::StoreTransaction,
+};
 use gw_traits::{ChainView, CodeStore};
 use gw_types::{
     bytes::Bytes,
@@ -405,7 +408,7 @@ impl Generator {
             "withdrawal count"
         );
 
-        let mut state = match db.state_tree(StateContext::AttachBlock(block_number)) {
+        let mut state = match BlockStateDB::from_store(db, RWConfig::attach_block(block_number)) {
             Ok(state) => state,
             Err(err) => {
                 log::error!("next state {}", err);
@@ -489,7 +492,12 @@ impl Generator {
             }
         }
 
-        let prev_txs_state = state.get_merkle_state();
+        let prev_txs_state = match state.finalise_merkle_state() {
+            Ok(s) => s,
+            Err(err) => {
+                return ApplyBlockResult::Error(err);
+            }
+        };
 
         // handle transactions
         let mut offchain_used_cycles: u64 = 0;
@@ -613,7 +621,7 @@ impl Generator {
                 }
 
                 let used_cycles = run_result.cycles.execution;
-                let post_state = match state.merkle_state() {
+                let post_state = match state.finalise_merkle_state() {
                     Ok(merkle_state) => merkle_state,
                     Err(err) => return ApplyBlockResult::Error(err),
                 };
@@ -630,7 +638,7 @@ impl Generator {
             let post_merkle_root: H256 = raw_block.post_account().merkle_root().unpack();
             let post_merkle_count: u32 = raw_block.post_account().count().unpack();
             assert_eq!(
-                state.calculate_root().expect("check post root"),
+                state.finalise_root().expect("check post root"),
                 post_merkle_root,
                 "post account merkle root must be consistent"
             );
diff --git a/crates/generator/src/genesis.rs b/crates/generator/src/genesis.rs
index 991d8c6b7..94cf0c9eb 100644
--- a/crates/generator/src/genesis.rs
+++ b/crates/generator/src/genesis.rs
@@ -3,13 +3,17 @@ use anyhow::Result;
 use gw_common::{
     blake2b::new_blake2b,
     builtins::{CKB_SUDT_ACCOUNT_ID, ETH_REGISTRY_ACCOUNT_ID, RESERVED_ACCOUNT_ID},
-    smt::H256,
+    smt::{H256, SMT},
     state::State,
     CKB_SUDT_SCRIPT_ARGS,
 };
 use gw_config::GenesisConfig;
 use gw_store::{
-    state::state_db::{StateContext, StateTree},
+    smt::smt_store::SMTStateStore,
+    state::{
+        history::history_state::{HistoryState, RWConfig},
+        state_db::StateDB,
+    },
     traits::chain_store::ChainStore,
     transaction::StoreTransaction,
     Store,
@@ -57,9 +61,11 @@ pub fn build_genesis_from_store(
     db.set_block_smt_root(H256::zero())?;
     db.set_reverted_block_smt_root(H256::zero())?;
 
+    // build genesis state tree
     let mut tree = {
-        let smt = db.account_smt_with_merkle_state(AccountMerkleState::default())?;
-        StateTree::new(smt, 0, StateContext::AttachBlock(0))
+        let smt = SMT::new(H256::zero(), SMTStateStore::new(&db));
+        let inner = HistoryState::new(smt, 0, RWConfig::attach_block(0));
+        StateDB::new(inner)
     };
 
     // create a reserved account
@@ -119,7 +125,7 @@ pub fn build_genesis_from_store(
 
     // calculate post state
     let post_account = {
-        let root = tree.calculate_root()?;
+        let root = tree.finalise_root()?;
         let count = tree.get_account_count()?;
         AccountMerkleState::new_builder()
             .merkle_root(root.pack())
diff --git a/crates/generator/src/lib.rs b/crates/generator/src/lib.rs
index 5f4d6834b..bf69f22d9 100644
--- a/crates/generator/src/lib.rs
+++ b/crates/generator/src/lib.rs
@@ -4,7 +4,6 @@
 pub mod account_lock_manage;
 pub mod backend_manage;
 pub mod constants;
-pub mod dummy_state;
 pub mod error;
 pub mod generator;
 pub mod genesis;
diff --git a/crates/generator/src/dummy_state.rs b/crates/generator/src/tests/dummy_state.rs
similarity index 99%
rename from crates/generator/src/dummy_state.rs
rename to crates/generator/src/tests/dummy_state.rs
index 06a8cd429..ee14884a9 100644
--- a/crates/generator/src/dummy_state.rs
+++ b/crates/generator/src/tests/dummy_state.rs
@@ -24,7 +24,7 @@ impl State for DummyState {
         self.tree.update(key, value)?;
         Ok(())
     }
-    fn calculate_root(&self) -> Result<H256, Error> {
+    fn finalise_root(&mut self) -> Result<H256, Error> {
         let root = *self.tree.root();
         Ok(root)
     }
diff --git a/crates/generator/src/tests/genesis.rs b/crates/generator/src/tests/genesis.rs
index 9bbc6c961..f87b9dc79 100644
--- a/crates/generator/src/tests/genesis.rs
+++ b/crates/generator/src/tests/genesis.rs
@@ -1,7 +1,11 @@
 use crate::genesis::{build_genesis, init_genesis};
 use gw_common::{sparse_merkle_tree::H256, state::State};
 use gw_config::GenesisConfig;
-use gw_store::{state::state_db::StateContext, traits::chain_store::ChainStore, Store};
+use gw_store::{
+    state::{history::history_state::RWConfig, BlockStateDB},
+    traits::chain_store::ChainStore,
+    Store,
+};
 use gw_traits::CodeStore;
 use gw_types::{bytes::Bytes, core::ScriptHashType, packed::RollupConfig, prelude::*};
 use std::convert::TryInto;
@@ -29,10 +33,10 @@ fn test_init_genesis() {
     assert_eq!(genesis_block_hash, GENESIS_BLOCK_HASH);
     let store: Store = Store::open_tmp().unwrap();
     init_genesis(&store, &config, &[0u8; 32], Bytes::default()).unwrap();
-    let db = store.begin_transaction();
+    let db = &store.begin_transaction();
     // check init values
     assert_ne!(db.get_block_smt_root().unwrap(), H256::zero());
-    let tree = db.state_tree(StateContext::ReadOnly).unwrap();
+    let mut tree = BlockStateDB::from_store(db, RWConfig::readonly()).unwrap();
     assert!(tree.get_account_count().unwrap() > 0);
 
     // check prev txs state
diff --git a/crates/generator/src/tests/mod.rs b/crates/generator/src/tests/mod.rs
index 237773a38..bbb406aff 100644
--- a/crates/generator/src/tests/mod.rs
+++ b/crates/generator/src/tests/mod.rs
@@ -1 +1,2 @@
+mod dummy_state;
 mod genesis;
diff --git a/crates/generator/src/traits.rs b/crates/generator/src/traits.rs
index c974222ec..0b60d8971 100644
--- a/crates/generator/src/traits.rs
+++ b/crates/generator/src/traits.rs
@@ -16,7 +16,7 @@ use tracing::instrument;
 
 pub trait StateExt {
     fn create_account_from_script(&mut self, script: Script) -> Result<u32, Error>;
-    fn merkle_state(&self) -> Result<AccountMerkleState, Error>;
+    fn finalise_merkle_state(&mut self) -> Result<AccountMerkleState, Error>;
     fn apply_run_result(&mut self, write: &RunResultWriteState) -> Result<(), Error>;
     fn apply_deposit_request(
         &mut self,
@@ -68,8 +68,10 @@ impl<S: State + CodeStore> StateExt for S {
         Ok(id)
     }
 
-    fn merkle_state(&self) -> Result<AccountMerkleState, Error> {
-        let account_root = self.calculate_root()?;
+    /// Finalise and return current merkle state
+    /// See finalise for drtails
+    fn finalise_merkle_state(&mut self) -> Result<AccountMerkleState, Error> {
+        let account_root = self.finalise_root()?;
         let account_count = self.get_account_count()?;
         let merkle_state = AccountMerkleState::new_builder()
             .merkle_root(account_root.pack())
@@ -254,7 +256,7 @@ impl<S: State + CodeStore> StateExt for S {
         self.set_nonce(id, new_nonce)?;
 
         let post_state = {
-            let account_root = self.calculate_root()?;
+            let account_root = self.finalise_root()?;
             let account_count = self.get_account_count()?;
             AccountMerkleState::new_builder()
                 .merkle_root(account_root.pack())
diff --git a/crates/generator/src/types/run_result_state.rs b/crates/generator/src/types/run_result_state.rs
index d68f8563a..f317aca7c 100644
--- a/crates/generator/src/types/run_result_state.rs
+++ b/crates/generator/src/types/run_result_state.rs
@@ -16,7 +16,7 @@ impl<'a> State for RunResultState<'a> {
         self.0.write.write_values.insert(key, value);
         Ok(())
     }
-    fn calculate_root(&self) -> Result<H256, gw_common::error::Error> {
+    fn finalise_root(&mut self) -> Result<H256, gw_common::error::Error> {
         // unsupported operation
         Err(gw_common::error::Error::MissingKey)
     }
diff --git a/crates/godwoken-bin/src/subcommand/db_block_validator.rs b/crates/godwoken-bin/src/subcommand/db_block_validator.rs
index 37ade5c82..7b2ec11ba 100644
--- a/crates/godwoken-bin/src/subcommand/db_block_validator.rs
+++ b/crates/godwoken-bin/src/subcommand/db_block_validator.rs
@@ -94,7 +94,7 @@ impl DBBlockCancelChallengeValidator {
     }
 
     fn verify_db(&self, from_block: Option<u64>, to_block: Option<u64>) -> Result<()> {
-        let db = self.store.begin_transaction();
+        let db = &self.store.begin_transaction();
         let from_block = from_block.unwrap_or(0);
         let to_block = match to_block {
             Some(to) => to,
@@ -115,7 +115,7 @@ impl DBBlockCancelChallengeValidator {
     }
 
     fn verify_block(&self, block_number: u64) -> Result<()> {
-        let db = self.store.begin_transaction();
+        let db = &self.store.begin_transaction();
         log::info!("verify block #{}", block_number);
 
         let block_hash: H256 = {
diff --git a/crates/godwoken-bin/src/subcommand/import_block.rs b/crates/godwoken-bin/src/subcommand/import_block.rs
index 793473608..acdd4e0d2 100644
--- a/crates/godwoken-bin/src/subcommand/import_block.rs
+++ b/crates/godwoken-bin/src/subcommand/import_block.rs
@@ -203,7 +203,7 @@ impl ImportBlock {
         // When the node starts it will sync with L1 and correct the last
         // confirmed block.
         if let Some(last_submitted_block) = last_submitted_block {
-            let tx_db = self.chain.store().begin_transaction();
+            let tx_db = &self.chain.store().begin_transaction();
             let block_hash = tx_db
                 .get_block_hash_by_number(last_submitted_block)?
                 .context("get block hash")?;
diff --git a/crates/mem-pool/src/deposit.rs b/crates/mem-pool/src/deposit.rs
index c47ad0b80..7faf9716e 100644
--- a/crates/mem-pool/src/deposit.rs
+++ b/crates/mem-pool/src/deposit.rs
@@ -1,7 +1,7 @@
 use anyhow::{anyhow, Result};
 use gw_common::{h256_ext::H256Ext, registry::context::RegistryContext, state::State, H256};
 use gw_config::DepositTimeoutConfig;
-use gw_store::state::mem_state_db::MemStateTree;
+use gw_store::state::MemStateDB;
 use gw_types::{
     bytes::Bytes,
     core::ScriptHashType,
@@ -18,7 +18,7 @@ pub fn sanitize_deposit_cells(
     ctx: &RollupContext,
     config: &DepositTimeoutConfig,
     unsanitize_deposits: Vec<DepositInfo>,
-    state: &MemStateTree,
+    state: &MemStateDB,
 ) -> Vec<DepositInfo> {
     log::debug!(target: "collect-deposit-cells", "sanitize {} deposits", unsanitize_deposits.len());
     let mut deposit_cells = Vec::with_capacity(unsanitize_deposits.len());
@@ -95,7 +95,7 @@ fn check_deposit_cell(
     ctx: &RollupContext,
     config: &DepositTimeoutConfig,
     cell: &DepositInfo,
-    state: &MemStateTree,
+    state: &MemStateDB,
 ) -> Result<()> {
     let hash_type = ScriptHashType::Type.into();
 
diff --git a/crates/mem-pool/src/fee/queue.rs b/crates/mem-pool/src/fee/queue.rs
index 13e1919b6..9445a0515 100644
--- a/crates/mem-pool/src/fee/queue.rs
+++ b/crates/mem-pool/src/fee/queue.rs
@@ -157,7 +157,8 @@ mod tests {
     use gw_config::GenesisConfig;
     use gw_generator::genesis::init_genesis;
     use gw_store::{
-        mem_pool_state::MemStore, state::state_db::StateContext, traits::chain_store::ChainStore,
+        state::{history::history_state::RWConfig, BlockStateDB, MemStateDB},
+        traits::chain_store::ChainStore,
         Store,
     };
     use gw_types::{
@@ -180,10 +181,10 @@ mod tests {
         let store = Store::open_tmp().expect("open store");
         setup_genesis(&store);
         {
-            let db = store.begin_transaction();
+            let db = &store.begin_transaction();
             let genesis = db.get_tip_block().expect("tip");
             assert_eq!(genesis.raw().number().unpack(), 0);
-            let mut state = db.state_tree(StateContext::AttachBlock(1)).expect("state");
+            let mut state = BlockStateDB::from_store(db, RWConfig::attach_block(1)).unwrap();
 
             // create accounts
             for i in 0..4 {
@@ -231,8 +232,7 @@ mod tests {
         queue.add(entry3, ());
         queue.add(entry4, ());
 
-        let mem_store = MemStore::new(snap);
-        let tree = mem_store.state().unwrap();
+        let tree = MemStateDB::from_store(snap).unwrap();
 
         // fetch 3
         {
@@ -262,10 +262,10 @@ mod tests {
         let store = Store::open_tmp().expect("open store");
         setup_genesis(&store);
         {
-            let db = store.begin_transaction();
+            let db = &store.begin_transaction();
             let genesis = db.get_tip_block().expect("tip");
             assert_eq!(genesis.raw().number().unpack(), 0);
-            let mut state = db.state_tree(StateContext::AttachBlock(1)).expect("state");
+            let mut state = BlockStateDB::from_store(db, RWConfig::attach_block(1)).unwrap();
 
             // create accounts
             for i in 0..4 {
@@ -316,8 +316,7 @@ mod tests {
 
         queue.add(entry4, ());
 
-        let mem_store = MemStore::new(snap);
-        let tree = mem_store.state().unwrap();
+        let tree = MemStateDB::from_store(snap).unwrap();
 
         // fetch 5
         {
@@ -337,10 +336,10 @@ mod tests {
         let store = Store::open_tmp().expect("open store");
         setup_genesis(&store);
         {
-            let db = store.begin_transaction();
+            let db = &store.begin_transaction();
             let genesis = db.get_tip_block().expect("tip");
             assert_eq!(genesis.raw().number().unpack(), 0);
-            let mut state = db.state_tree(StateContext::AttachBlock(1)).expect("state");
+            let mut state = BlockStateDB::from_store(db, RWConfig::attach_block(1)).unwrap();
 
             // create accounts
             for i in 0..4 {
@@ -378,8 +377,7 @@ mod tests {
         queue.add(entry2, ());
 
         let snap = store.get_snapshot();
-        let mem_store = MemStore::new(snap);
-        let tree = mem_store.state().unwrap();
+        let tree = MemStateDB::from_store(snap).unwrap();
 
         // fetch
         {
@@ -397,10 +395,10 @@ mod tests {
         let store = Store::open_tmp().expect("open store");
         setup_genesis(&store);
         {
-            let db = store.begin_transaction();
+            let db = &store.begin_transaction();
             let genesis = db.get_tip_block().expect("tip");
             assert_eq!(genesis.raw().number().unpack(), 0);
-            let mut state = db.state_tree(StateContext::AttachBlock(1)).expect("state");
+            let mut state = BlockStateDB::from_store(db, RWConfig::attach_block(1)).unwrap();
 
             // create accounts
             for i in 0..4 {
@@ -438,8 +436,7 @@ mod tests {
         queue.add(entry2, ());
 
         let snap = store.get_snapshot();
-        let mem_store = MemStore::new(snap);
-        let tree = mem_store.state().unwrap();
+        let tree = MemStateDB::from_store(snap).unwrap();
 
         // fetch
         {
@@ -459,10 +456,10 @@ mod tests {
         let store = Store::open_tmp().expect("open store");
         setup_genesis(&store);
         {
-            let db = store.begin_transaction();
+            let db = &store.begin_transaction();
             let genesis = db.get_tip_block().expect("tip");
             assert_eq!(genesis.raw().number().unpack(), 0);
-            let mut state = db.state_tree(StateContext::AttachBlock(1)).expect("state");
+            let mut state = BlockStateDB::from_store(db, RWConfig::attach_block(1)).unwrap();
 
             // create accounts
             for i in 0..4 {
@@ -520,10 +517,10 @@ mod tests {
         let store = Store::open_tmp().expect("open store");
         setup_genesis(&store);
         {
-            let db = store.begin_transaction();
+            let db = &store.begin_transaction();
             let genesis = db.get_tip_block().expect("tip");
             assert_eq!(genesis.raw().number().unpack(), 0);
-            let mut state = db.state_tree(StateContext::AttachBlock(1)).expect("state");
+            let mut state = BlockStateDB::from_store(db, RWConfig::attach_block(1)).unwrap();
 
             // create accounts
             for i in 0..4 {
@@ -571,8 +568,7 @@ mod tests {
         queue.add(entry3, ());
         queue.add(entry4, ());
 
-        let mem_store = MemStore::new(snap);
-        let tree = mem_store.state().unwrap();
+        let tree = MemStateDB::from_store(snap).unwrap();
 
         // fetch 3
         {
@@ -608,10 +604,10 @@ mod tests {
         let store = Store::open_tmp().expect("open store");
         setup_genesis(&store);
         {
-            let db = store.begin_transaction();
+            let db = &store.begin_transaction();
             let genesis = db.get_tip_block().expect("tip");
             assert_eq!(genesis.raw().number().unpack(), 0);
-            let mut state = db.state_tree(StateContext::AttachBlock(1)).expect("state");
+            let mut state = BlockStateDB::from_store(db, RWConfig::attach_block(1)).unwrap();
 
             // create accounts
             for i in 0..4 {
@@ -662,8 +658,7 @@ mod tests {
 
         queue.add(entry4, ());
 
-        let mem_store = MemStore::new(snap);
-        let tree = mem_store.state().unwrap();
+        let tree = MemStateDB::from_store(snap).unwrap();
 
         // fetch 5
         {
@@ -717,8 +712,7 @@ mod tests {
         queue.add(entry2, ());
 
         let snap = store.get_snapshot();
-        let mem_store = MemStore::new(snap);
-        let tree = mem_store.state().unwrap();
+        let tree = MemStateDB::from_store(snap).unwrap();
 
         // fetch
         {
@@ -764,8 +758,7 @@ mod tests {
         queue.add(entry2, ());
 
         let snap = store.get_snapshot();
-        let mem_store = MemStore::new(snap);
-        let tree = mem_store.state().unwrap();
+        let tree = MemStateDB::from_store(snap).unwrap();
 
         // fetch
         {
diff --git a/crates/mem-pool/src/pool.rs b/crates/mem-pool/src/pool.rs
index 257070883..2f74c3a6a 100644
--- a/crates/mem-pool/src/pool.rs
+++ b/crates/mem-pool/src/pool.rs
@@ -25,8 +25,8 @@ use gw_generator::{
 };
 use gw_store::{
     chain_view::ChainView,
-    mem_pool_state::{MemPoolState, MemStore},
-    state::mem_state_db::MemStateTree,
+    mem_pool_state::{self, MemPoolState, Shared},
+    state::MemStateDB,
     traits::chain_store::ChainStore,
     transaction::StoreTransaction,
     Store,
@@ -57,6 +57,8 @@ use crate::{
     traits::MemPoolProvider, types::EntryList, withdrawal::Generator as WithdrawalGenerator,
 };
 
+type StateDB = gw_store::state::MemStateDB;
+
 #[derive(Debug, Default)]
 pub struct OutputParam {
     pub retry_count: usize,
@@ -72,6 +74,7 @@ impl OutputParam {
 pub struct MemPool {
     /// store
     store: Store,
+    mem_pool_state: Arc<MemPoolState>,
     /// current tip
     current_tip: (H256, u64),
     /// generator instance
@@ -88,7 +91,6 @@ pub struct MemPool {
     restore_manager: RestoreManager,
     /// Restored txs to finalize
     pending_restored_tx_hashes: VecDeque<H256>,
-    mem_pool_state: Arc<MemPoolState>,
     dynamic_config_manager: Arc<ArcSwap<DynamicConfigManager>>,
     sync_server: Option<Arc<std::sync::Mutex<BlockSyncServerState>>>,
     mem_block_config: MemBlockConfig,
@@ -132,7 +134,7 @@ impl MemPool {
         let pending = Default::default();
 
         let tip_block = {
-            let db = store.begin_transaction();
+            let db = &store.begin_transaction();
             db.get_last_valid_tip_block()?
         };
         let tip = (tip_block.hash().into(), tip_block.raw().number().unpack());
@@ -155,8 +157,8 @@ impl MemPool {
         mem_block.clear_txs();
 
         let mem_pool_state = {
-            let mem_store = MemStore::new(store.get_snapshot());
-            Arc::new(MemPoolState::new(Arc::new(mem_store), false))
+            let state_db = MemStateDB::from_store(store.get_snapshot())?;
+            Arc::new(MemPoolState::new(state_db, false))
         };
 
         let cycles_pool = CyclesPool::new(
@@ -184,9 +186,9 @@ impl MemPool {
         mem_pool.remove_reinjected_failed_txs()?;
 
         // update mem block info
-        let snap = mem_pool.mem_pool_state().load();
-        snap.update_mem_pool_block_info(mem_pool.mem_block.block_info())?;
-        mem_pool.mem_pool_state().store(snap.into());
+        let mut shared = mem_pool.mem_pool_state().load_shared();
+        shared.mem_block = Some(mem_pool.mem_block.block_info().to_owned());
+        mem_pool.mem_pool_state().store_shared(Arc::new(shared));
 
         // set tip
         if matches!(node_mode, NodeMode::ReadOnly) {
@@ -276,11 +278,10 @@ impl MemPool {
         tokio::task::block_in_place(|| {
             let db = self.store.begin_transaction();
 
-            let snap = self.mem_pool_state.load();
-            let mut state = snap.state()?;
+            let mut state = self.mem_pool_state.load_state_db();
             self.push_transaction_with_db(&db, &mut state, tx)?;
             db.commit()?;
-            self.mem_pool_state.store(snap.into());
+            self.mem_pool_state.store_state_db(state);
 
             Ok(())
         })
@@ -291,7 +292,7 @@ impl MemPool {
     fn push_transaction_with_db(
         &mut self,
         db: &StoreTransaction,
-        state: &mut MemStateTree<'_>,
+        state: &mut StateDB,
         tx: L2Transaction,
     ) -> Result<()> {
         // check duplication
@@ -347,9 +348,9 @@ impl MemPool {
             return Err(anyhow!("duplicated withdrawal"));
         }
 
-        // basic verification
-        let snap = self.mem_pool_state.load();
-        let state = snap.state()?;
+        // basic verification without write into state
+        // withdrawals will be write into state in the finalize_withdrawals function
+        let state = self.mem_pool_state.load_state_db();
         self.verify_withdrawal_request(&withdrawal, &state).await?;
 
         // Check replace-by-fee
@@ -421,7 +422,7 @@ impl MemPool {
         withdrawal_generator.verify_remained_amount(&withdrawal.request())?;
 
         // withdrawal basic verification
-        let db = self.store.begin_transaction();
+        let db = &self.store.begin_transaction();
         let asset_script = db.get_asset_script(&withdrawal.raw().sudt_script_hash().unpack())?;
         WithdrawalVerifier::new(state, self.generator.rollup_context())
             .verify(withdrawal, asset_script)
@@ -521,9 +522,11 @@ impl MemPool {
             // re-injecting discarded txs/withdrawals.
             let snapshot = self.store.get_snapshot();
             self.mem_block.reset(&new_tip_block, Duration::ZERO);
-            let mem_store = MemStore::new(snapshot);
-            mem_store.update_mem_pool_block_info(self.mem_block.block_info())?;
-            self.mem_pool_state.store(Arc::new(mem_store));
+            let shared = mem_pool_state::Shared {
+                state_db: MemStateDB::from_store(snapshot)?,
+                mem_block: Some(self.mem_block.block_info().to_owned()),
+            };
+            self.mem_pool_state.store_shared(Arc::new(shared));
         }
 
         Ok(())
@@ -636,13 +639,13 @@ impl MemPool {
             }
         }
 
-        let db = self.store.begin_transaction();
+        let db = &self.store.begin_transaction();
 
         let is_mem_pool_recovery = old_tip.is_none();
 
         // refresh pending deposits
         if !is_mem_pool_recovery {
-            self.refresh_deposit_cells(&db, new_tip, local_cells_manager)
+            self.refresh_deposit_cells(db, new_tip, local_cells_manager)
                 .await?;
         }
 
@@ -691,12 +694,11 @@ impl MemPool {
             };
 
             // create new mem_store to maintain memory state
-            let mem_store = MemStore::new(snapshot);
-            mem_store.update_mem_pool_block_info(self.mem_block.block_info())?;
-            let mut mem_state = mem_store.state()?;
+            let mut state_db = StateDB::from_store(snapshot)?;
+            let mem_block = self.mem_block.block_info().to_owned();
 
             // remove from pending
-            self.remove_unexecutables(&mut mem_state, &db)?;
+            self.remove_unexecutables(&mut state_db, db)?;
 
             log::info!("[mem-pool] reset reinject txs: {} mem-block txs: {} reinject withdrawals: {} mem-block withdrawals: {}", reinject_txs.len(), mem_block_txs.len(), reinject_withdrawals.len(), mem_block_withdrawals.len());
             // re-inject txs
@@ -709,15 +711,15 @@ impl MemPool {
                 withdrawals.extend(mem_block_withdrawals);
             } else {
                 // packages more withdrawals
-                self.try_package_more_withdrawals(&mem_state, &mut withdrawals);
+                self.try_package_more_withdrawals(&state_db, &mut withdrawals);
             }
 
             // To simplify logic, don't restrict reinjected txs
             self.cycles_pool = CyclesPool::new(u64::MAX, SyscallCyclesConfig::default());
 
             self.prepare_next_mem_block(
-                &db,
-                &mut mem_state,
+                db,
+                &mut state_db,
                 withdrawals,
                 self.pending_deposits.clone(),
                 txs,
@@ -732,7 +734,11 @@ impl MemPool {
             self.cycles_pool.consume_cycles(used_cycles);
 
             // store mem state
-            self.mem_pool_state.store(Arc::new(mem_store));
+            let shared = Shared {
+                state_db,
+                mem_block: Some(mem_block),
+            };
+            self.mem_pool_state.store_shared(Arc::new(shared));
             db.commit()?;
 
             Ok(())
@@ -741,14 +747,11 @@ impl MemPool {
 
     fn try_package_more_withdrawals(
         &self,
-        mem_state: &MemStateTree<'_>,
+        state: &StateDB,
         withdrawals: &mut Vec<WithdrawalRequestExtra>,
     ) {
         // packages mem withdrawals
-        fn filter_withdrawals(
-            state: &MemStateTree<'_>,
-            withdrawal: &WithdrawalRequestExtra,
-        ) -> bool {
+        fn filter_withdrawals(state: &StateDB, withdrawal: &WithdrawalRequestExtra) -> bool {
             let id = state
                 .get_account_id_by_script_hash(&withdrawal.raw().account_script_hash().unpack())
                 .expect("get id")
@@ -757,13 +760,13 @@ impl MemPool {
             let expected_nonce: u32 = withdrawal.raw().nonce().unpack();
             expected_nonce >= nonce
         }
-        withdrawals.retain(|w| filter_withdrawals(mem_state, w));
+        withdrawals.retain(|w| filter_withdrawals(state, w));
 
         // package withdrawals
         if withdrawals.len() < self.mem_block_config.max_withdrawals {
             for entry in self.pending().values() {
                 if let Some(withdrawal) = entry.withdrawals.first() {
-                    if filter_withdrawals(mem_state, withdrawal) {
+                    if filter_withdrawals(state, withdrawal) {
                         withdrawals.push(withdrawal.clone());
                     }
                     if withdrawals.len() >= self.mem_block_config.max_withdrawals {
@@ -776,11 +779,7 @@ impl MemPool {
 
     /// Discard unexecutables from pending.
     #[instrument(skip_all)]
-    fn remove_unexecutables(
-        &mut self,
-        state: &mut MemStateTree<'_>,
-        db: &StoreTransaction,
-    ) -> Result<()> {
+    fn remove_unexecutables(&mut self, state: &mut StateDB, db: &StoreTransaction) -> Result<()> {
         let mut remove_list = Vec::default();
         // iter pending accounts and demote any non-executable objects
         for (&account_id, list) in &mut self.pending {
@@ -827,13 +826,13 @@ impl MemPool {
     fn prepare_next_mem_block(
         &mut self,
         db: &StoreTransaction,
-        state: &mut MemStateTree<'_>,
+        state: &mut StateDB,
         withdrawals: Vec<WithdrawalRequestExtra>,
         deposit_cells: Vec<DepositInfo>,
         mut txs: Vec<L2Transaction>,
     ) -> Result<()> {
         // remove txs nonce is lower than current state
-        fn filter_tx(state: &MemStateTree<'_>, tx: &L2Transaction) -> bool {
+        fn filter_tx(state: &StateDB, tx: &L2Transaction) -> bool {
             let raw_tx = tx.raw();
             let nonce = state
                 .get_nonce(raw_tx.from_id().unpack())
@@ -901,8 +900,7 @@ impl MemPool {
         local_cells_manager: &LocalCellsManager,
     ) -> Result<()> {
         // refresh
-        let snap = self.mem_pool_state.load();
-        let state = snap.state()?;
+        let state = self.mem_pool_state.load_state_db();
         let mem_account_count = state.get_account_count()?;
         let tip_account_count: u32 = {
             let new_tip_block = db
@@ -937,25 +935,25 @@ impl MemPool {
     #[instrument(skip_all, fields(deposits_count = deposit_cells.len()))]
     fn finalize_deposits(
         &mut self,
-        state: &mut MemStateTree<'_>,
+        state: &mut StateDB,
         deposit_cells: Vec<DepositInfo>,
     ) -> Result<()> {
-        state.tracker_mut().enable();
+        state.set_state_tracker(Default::default());
         // update deposits
         let deposits: Vec<_> = deposit_cells.iter().map(|c| c.request.clone()).collect();
         let mut post_states = Vec::with_capacity(deposits.len());
         let mut touched_keys_vec = Vec::with_capacity(deposits.len());
         for deposit in deposits {
             state.apply_deposit_request(self.generator.rollup_context(), &deposit)?;
-
-            post_states.push(state.get_merkle_state());
-            let touched_keys = state.tracker_mut().touched_keys().expect("touched keys");
+            let touched_keys = state.state_tracker().unwrap().touched_keys();
             touched_keys_vec.push(touched_keys.lock().unwrap().drain().collect());
+            post_states.push(state.finalise_merkle_state()?);
         }
+        state.take_state_tracker();
         // calculate state after withdrawals & deposits
         let prev_state_checkpoint = state.calculate_state_checkpoint()?;
         log::debug!("[finalize deposits] deposits: {} state root: {}, account count: {}, prev_state_checkpoint {}",
-         deposit_cells.len(), hex::encode(state.calculate_root()?.as_slice()), state.get_account_count()?, hex::encode(prev_state_checkpoint.as_slice()));
+         deposit_cells.len(), hex::encode(state.finalise_root()?.as_slice()), state.get_account_count()?, hex::encode(prev_state_checkpoint.as_slice()));
 
         self.mem_block.push_deposits(
             deposit_cells,
@@ -963,7 +961,6 @@ impl MemPool {
             touched_keys_vec,
             prev_state_checkpoint,
         );
-        state.submit_tree_to_mem_block();
 
         Ok(())
     }
@@ -972,7 +969,7 @@ impl MemPool {
     #[instrument(skip_all, fields(withdrawals_count = withdrawals.len()))]
     fn finalize_withdrawals(
         &mut self,
-        state: &mut MemStateTree<'_>,
+        state: &mut StateDB,
         db: &StoreTransaction,
         withdrawals: Vec<WithdrawalRequestExtra>,
     ) -> Result<()> {
@@ -996,7 +993,7 @@ impl MemPool {
             finalized_custodians,
         );
         // start track withdrawal
-        state.tracker_mut().enable();
+        state.set_state_tracker(Default::default());
         for withdrawal in withdrawals {
             let withdrawal_hash = withdrawal.hash();
             // check withdrawal request
@@ -1037,8 +1034,8 @@ impl MemPool {
                 &withdrawal.request(),
             ) {
                 Ok(_) => {
-                    let post_state = state.get_merkle_state();
-                    let touched_keys = state.tracker_mut().touched_keys().expect("touched keys");
+                    let post_state = state.finalise_merkle_state()?;
+                    let touched_keys = state.state_tracker().unwrap().touched_keys();
 
                     let withdrawal_hash = withdrawal.hash().into();
 
@@ -1068,7 +1065,7 @@ impl MemPool {
                 }
             }
         }
-        state.submit_tree_to_mem_block();
+        state.take_state_tracker();
         self.mem_block
             .set_finalized_custodian_capacity(withdrawal_verifier.remaining_capacity());
 
@@ -1086,11 +1083,11 @@ impl MemPool {
     fn execute_tx(
         &mut self,
         db: &StoreTransaction,
-        state: &mut MemStateTree<'_>,
+        state: &mut StateDB,
         tx: L2Transaction,
     ) -> Result<TxReceipt> {
         let tip_block_hash = db.get_tip_block_hash()?;
-        let chain_view = ChainView::new(db, tip_block_hash);
+        let chain_view = ChainView::new(&db, tip_block_hash);
 
         let block_info = self.mem_block.block_info();
 
@@ -1154,15 +1151,9 @@ impl MemPool {
             "[finalize tx] apply run result: {}ms",
             t.elapsed().as_millis()
         );
-        let t = Instant::now();
-        state.submit_tree_to_mem_block();
-        log::debug!(
-            "[finalize tx] submit tree to mem_block: {}ms",
-            t.elapsed().as_millis()
-        );
 
         // generate tx receipt
-        let merkle_state = state.merkle_state()?;
+        let merkle_state = state.finalise_merkle_state()?;
         let tx_receipt =
             TxReceipt::build_receipt(tx.witness_hash().into(), run_result, merkle_state);
 
@@ -1268,23 +1259,26 @@ impl MemPool {
             let mem_block = MemBlock::new(block_info, post_merkle_state);
             self.mem_block = mem_block;
 
-            let mem_store = MemStore::new(snapshot);
-            mem_store.update_mem_pool_block_info(self.mem_block.block_info())?;
-            let mut mem_state = mem_store.state()?;
+            let mut state = StateDB::from_store(snapshot)?;
+            let mem_block = self.mem_block.block_info().to_owned();
 
             // remove from pending
             let db = self.store.begin_transaction();
-            self.remove_unexecutables(&mut mem_state, &db)?;
+            self.remove_unexecutables(&mut state, &db)?;
 
             // reset cycles pool available cycles.
             self.cycles_pool = CyclesPool::new(u64::MAX, SyscallCyclesConfig::default());
 
             // prepare next mem block
-            self.try_package_more_withdrawals(&mem_state, &mut withdrawals);
-            self.prepare_next_mem_block(&db, &mut mem_state, withdrawals, deposits, mem_block_txs)?;
+            self.try_package_more_withdrawals(&state, &mut withdrawals);
+            self.prepare_next_mem_block(&db, &mut state, withdrawals, deposits, mem_block_txs)?;
 
             // update mem state
-            self.mem_pool_state.store(Arc::new(mem_store));
+            let shared = Shared {
+                state_db: state,
+                mem_block: Some(mem_block),
+            };
+            self.mem_pool_state.store_shared(Arc::new(shared));
             db.commit()?;
 
             let mem_block = &self.mem_block;
diff --git a/crates/polyjuice-sender-recover/src/mem_execute_tx_state.rs b/crates/polyjuice-sender-recover/src/mem_execute_tx_state.rs
index 3d095d073..dbe2f148e 100644
--- a/crates/polyjuice-sender-recover/src/mem_execute_tx_state.rs
+++ b/crates/polyjuice-sender-recover/src/mem_execute_tx_state.rs
@@ -66,7 +66,7 @@ impl<S: State + CodeStore> State for MemExecuteTxStateTree<S> {
         Ok(())
     }
 
-    fn calculate_root(&self) -> Result<H256, StateError> {
+    fn finalise_root(&mut self) -> Result<H256, StateError> {
         log::error!("calculate_root is unsupport in executetx state");
         Err(StateError::Store)
     }
diff --git a/crates/replay-chain/src/replay.rs b/crates/replay-chain/src/replay.rs
index 062088812..587733091 100644
--- a/crates/replay-chain/src/replay.rs
+++ b/crates/replay-chain/src/replay.rs
@@ -3,7 +3,10 @@ use std::{convert::TryInto, time::Instant};
 use crate::setup::Context as ChainContext;
 use anyhow::{anyhow, Result};
 use gw_common::H256;
-use gw_store::{state::state_db::StateContext, traits::chain_store::ChainStore};
+use gw_store::{
+    state::{history::history_state::RWConfig, BlockStateDB},
+    traits::chain_store::ChainStore,
+};
 use gw_types::{
     core::ChallengeTargetType,
     packed::Byte32,
@@ -121,7 +124,7 @@ pub fn detach_chain(ctx: ChainContext) -> Result<()> {
 
     // query next block
     while number > 0 {
-        let db = local_store.begin_transaction();
+        let db = &local_store.begin_transaction();
         let detach_block = {
             let block_hash = db.get_block_hash_by_number(number)?.unwrap();
             db.get_block(&block_hash)?.unwrap()
@@ -131,8 +134,8 @@ pub fn detach_chain(ctx: ChainContext) -> Result<()> {
         println!("Detach block: #{} {}", number, hash);
         db.detach_block(&detach_block)?;
         {
-            let mut state = db.state_tree(StateContext::DetachBlock(number))?;
-            state.detach_block_state()?;
+            let mut state = BlockStateDB::from_store(db, RWConfig::detach_block())?;
+            state.detach_block_state(number)?;
         }
         db.commit()?;
         local_store.check_state()?;
diff --git a/crates/rpc-server/src/registry.rs b/crates/rpc-server/src/registry.rs
index f4697f117..ababac4b4 100644
--- a/crates/rpc-server/src/registry.rs
+++ b/crates/rpc-server/src/registry.rs
@@ -36,11 +36,10 @@ use gw_polyjuice_sender_recover::{
     mem_execute_tx_state::MemExecuteTxStateTree, recover::PolyjuiceSenderRecover,
 };
 use gw_rpc_client::rpc_client::RPCClient;
+use gw_store::state::history::history_state::RWConfig;
+use gw_store::state::{BlockStateDB, MemStateDB};
 use gw_store::{
-    chain_view::ChainView,
-    mem_pool_state::{MemPoolState, MemStore},
-    state::state_db::StateContext,
-    traits::chain_store::ChainStore,
+    chain_view::ChainView, mem_pool_state::MemPoolState, traits::chain_store::ChainStore,
     CfMemStat, Store,
 };
 use gw_traits::CodeStore;
@@ -223,7 +222,7 @@ impl Registry {
                 mem_pool.mem_pool_state()
             }
             None => Arc::new(MemPoolState::new(
-                Arc::new(MemStore::new(store.get_snapshot())),
+                MemStateDB::from_store(store.get_snapshot()).expect("mem state DB"),
                 true,
             )),
         };
@@ -462,7 +461,7 @@ impl RequestSubmitter {
     async fn in_background(mut self) {
         // First mem pool reinject txs
         {
-            let db = self.store.begin_transaction();
+            let db = &self.store.begin_transaction();
             let mut mem_pool = self.mem_pool.lock().await;
 
             log::info!(
@@ -533,8 +532,7 @@ impl RequestSubmitter {
                         return;
                     }
                 };
-                let snap = self.mem_pool_state.load();
-                let state = snap.state().expect("get mem state");
+                let state = self.mem_pool_state.load_state_db();
                 let kind = req.kind();
                 let hash = req.hash();
                 let dynamic_config_manager = self.dynamic_config_manager.load();
@@ -563,8 +561,7 @@ impl RequestSubmitter {
             }
 
             // push txs to fee priority queue
-            let snap = self.mem_pool_state.load();
-            let state = snap.state().expect("get mem state");
+            let state = self.mem_pool_state.load_state_db();
             while let Ok((handle, req)) = self.submit_rx.try_recv() {
                 let kind = req.kind();
                 let hash = req.hash();
@@ -649,8 +646,7 @@ impl RequestSubmitter {
                     log::error!("[tx from zero] create account {}", err);
                 }
 
-                let snap = self.mem_pool_state.load();
-                let state = snap.state().expect("get mem state");
+                let state = self.mem_pool_state.load_state_db();
                 let mut block_cycles_limit_reached = false;
 
                 for (entry, handle) in items {
@@ -868,7 +864,7 @@ async fn get_block(
     rollup_config: Data<RollupConfig>,
 ) -> Result<Option<L2BlockWithStatus>> {
     let block_hash = to_h256(block_hash);
-    let db = store.begin_transaction();
+    let db = &store.begin_transaction();
     let block = match db.get_block(&block_hash)? {
         Some(block) => block,
         None => return Ok(None),
@@ -904,10 +900,10 @@ async fn get_block(
 
 async fn get_block_by_number(
     Params((block_number,)): Params<(gw_jsonrpc_types::ckb_jsonrpc_types::Uint64,)>,
-    mem_pool_state: Data<Arc<MemPoolState>>,
+    store: Data<Store>,
 ) -> Result<Option<L2BlockView>> {
     let block_number = block_number.value();
-    let snap = mem_pool_state.load();
+    let snap = store.get_snapshot();
     let block_hash = match snap.get_block_hash_by_number(block_number)? {
         Some(hash) => hash,
         None => return Ok(None),
@@ -921,16 +917,16 @@ async fn get_block_by_number(
 
 async fn get_block_hash(
     Params((block_number,)): Params<(gw_jsonrpc_types::ckb_jsonrpc_types::Uint64,)>,
-    mem_pool_state: Data<Arc<MemPoolState>>,
+    store: Data<Store>,
 ) -> Result<Option<JsonH256>> {
     let block_number = block_number.value();
-    let db = mem_pool_state.load();
+    let db = store.get_snapshot();
     let hash_opt = db.get_block_hash_by_number(block_number)?.map(to_jsonh256);
     Ok(hash_opt)
 }
 
-async fn get_tip_block_hash(mem_pool_state: Data<Arc<MemPoolState>>) -> Result<JsonH256> {
-    let tip_block_hash = mem_pool_state.load().get_last_valid_tip_block_hash()?;
+async fn get_tip_block_hash(store: Data<Store>) -> Result<JsonH256> {
+    let tip_block_hash = store.get_last_valid_tip_block_hash()?;
     Ok(to_jsonh256(tip_block_hash))
 }
 
@@ -1014,8 +1010,7 @@ async fn execute_l2transaction(
     // NOTE: for tx from id 0, it's balance will be verified after mock account
     let from_id: u32 = tx.raw().from_id().unpack();
     if 0 != from_id {
-        let snap = ctx.mem_pool_state.load();
-        let state = snap.state()?;
+        let state = ctx.mem_pool_state.load_state_db();
         if let Err(err) = verify_sender_balance(ctx.generator.rollup_context(), &state, &tx.raw()) {
             return Err(RpcError::Full {
                 code: INVALID_REQUEST,
@@ -1029,9 +1024,8 @@ async fn execute_l2transaction(
         let db = ctx.store.get_snapshot();
         let tip_block_hash = db.get_last_valid_tip_block_hash()?;
         let chain_view = ChainView::new(&db, tip_block_hash);
-        let snap = ctx.mem_pool_state.load();
-        let mem_state = snap.state()?;
-        let mut state = MemExecuteTxStateTree::new(mem_state);
+        let state = ctx.mem_pool_state.load_state_db();
+        let mut state = MemExecuteTxStateTree::new(state);
         let mut cycles_pool = CyclesPool::new(
             ctx.mem_pool_config.mem_block.max_cycles_limit,
             ctx.mem_pool_config.mem_block.syscall_cycles.clone(),
@@ -1116,12 +1110,11 @@ async fn execute_raw_l2transaction(
     let raw_l2tx_bytes = raw_l2tx.into_bytes();
     let raw_l2tx = packed::RawL2Transaction::from_slice(&raw_l2tx_bytes)?;
 
-    let db = ctx.store.begin_transaction();
-
-    let mem_state_snap = ctx.mem_pool_state.load();
+    let db_txn = ctx.store.begin_transaction();
 
     let block_info = match block_number_opt {
         Some(block_number) => {
+            let db = &db_txn;
             let block_hash = match db.get_block_hash_by_number(block_number)? {
                 Some(block_hash) => block_hash,
                 None => return Err(header_not_found_err()),
@@ -1140,8 +1133,9 @@ async fn execute_raw_l2transaction(
                 .number(number.pack())
                 .build()
         }
-        None => mem_state_snap
-            .get_mem_pool_block_info()?
+        None => ctx
+            .mem_pool_state
+            .get_mem_pool_block_info()
             .expect("get mem pool block info"),
     };
 
@@ -1159,12 +1153,12 @@ async fn execute_raw_l2transaction(
     if 0 != from_id {
         let check_balance_result = match block_number_opt {
             Some(block_number) => {
-                let state = db.state_tree(StateContext::ReadOnlyHistory(block_number))?;
+                let db = &db_txn;
+                let state = BlockStateDB::from_store(db, RWConfig::history_block(block_number))?;
                 verify_sender_balance(ctx.generator.rollup_context(), &state, &raw_l2tx)
             }
             None => {
-                let snap = ctx.mem_pool_state.load();
-                let state = snap.state()?;
+                let state = ctx.mem_pool_state.load_state_db();
                 verify_sender_balance(ctx.generator.rollup_context(), &state, &raw_l2tx)
             }
         };
@@ -1181,6 +1175,7 @@ async fn execute_raw_l2transaction(
     let mut run_result = tokio::task::spawn_blocking(move || {
         let eth_recover = &ctx.polyjuice_sender_recover.eth;
         let rollup_context = ctx.generator.rollup_context();
+        let db = &db_txn;
         let chain_view = {
             let tip_block_hash = db.get_last_valid_tip_block_hash()?;
             ChainView::new(&db, tip_block_hash)
@@ -1188,8 +1183,9 @@ async fn execute_raw_l2transaction(
         // execute tx
         let run_result = match block_number_opt {
             Some(block_number) => {
-                let hist_state = db.state_tree(StateContext::ReadOnlyHistory(block_number))?;
-                let mut state = MemExecuteTxStateTree::new(hist_state);
+                let history_state =
+                    BlockStateDB::from_store(db, RWConfig::history_block(block_number))?;
+                let mut state = MemExecuteTxStateTree::new(history_state);
                 let raw_l2tx = eth_recover.mock_sender_if_not_exists_from_raw_registry(
                     raw_l2tx,
                     registry_address_opt,
@@ -1210,7 +1206,7 @@ async fn execute_raw_l2transaction(
                 )?
             }
             None => {
-                let state = mem_state_snap.state()?;
+                let state = ctx.mem_pool_state.load_state_db();
                 let mut state = MemExecuteTxStateTree::new(state);
                 let raw_l2tx = eth_recover.mock_sender_if_not_exists_from_raw_registry(
                     raw_l2tx,
@@ -1302,14 +1298,13 @@ async fn submit_l2transaction(
     // check sender's nonce
     {
         // fetch mem-pool state
-        let snap = ctx.mem_pool_state.load();
-        let tree = snap.state()?;
+        let state = ctx.mem_pool_state.load_state_db();
 
         let tx_nonce: u32 = tx.raw().nonce().unpack();
         let sender_nonce: u32 = if 0 == sender_id {
             0
         } else {
-            tree.get_nonce(sender_id)?
+            state.get_nonce(sender_id)?
         };
         if sender_nonce != tx_nonce {
             let err = TransactionError::Nonce {
@@ -1558,13 +1553,12 @@ async fn get_balance(
     let balance = match block_number {
         Some(block_number) => {
             let db = store.begin_transaction();
-            let tree = db.state_tree(StateContext::ReadOnlyHistory(block_number.into()))?;
+            let tree = BlockStateDB::from_store(&db, RWConfig::history_block(block_number.into()))?;
             tree.get_sudt_balance(sudt_id.into(), &address)?
         }
         None => {
-            let snap = mem_pool_state.load();
-            let tree = snap.state()?;
-            tree.get_sudt_balance(sudt_id.into(), &address)?
+            let state = mem_pool_state.load_state_db();
+            state.get_sudt_balance(sudt_id.into(), &address)?
         }
     };
     Ok(balance)
@@ -1591,15 +1585,14 @@ async fn get_storage_at(
     let value = match block_number {
         Some(block_number) => {
             let db = store.begin_transaction();
-            let tree = db.state_tree(StateContext::ReadOnlyHistory(block_number.into()))?;
+            let tree = BlockStateDB::from_store(&db, RWConfig::history_block(block_number.into()))?;
             let key: H256 = to_h256(key);
             tree.get_value(account_id.into(), key.as_slice())?
         }
         None => {
-            let snap = mem_pool_state.load();
-            let tree = snap.state()?;
+            let state = mem_pool_state.load_state_db();
             let key: H256 = to_h256(key);
-            tree.get_value(account_id.into(), key.as_slice())?
+            state.get_value(account_id.into(), key.as_slice())?
         }
     };
 
@@ -1611,12 +1604,11 @@ async fn get_account_id_by_script_hash(
     Params((script_hash,)): Params<(JsonH256,)>,
     mem_pool_state: Data<Arc<MemPoolState>>,
 ) -> Result<Option<AccountID>, RpcError> {
-    let snap = mem_pool_state.load();
-    let tree = snap.state()?;
+    let state = mem_pool_state.load_state_db();
 
     let script_hash = to_h256(script_hash);
 
-    let account_id_opt = tree
+    let account_id_opt = state
         .get_account_id_by_script_hash(&script_hash)?
         .map(Into::into);
 
@@ -1644,13 +1636,12 @@ async fn get_nonce(
     let nonce = match block_number {
         Some(block_number) => {
             let db = store.begin_transaction();
-            let tree = db.state_tree(StateContext::ReadOnlyHistory(block_number.into()))?;
+            let tree = BlockStateDB::from_store(&db, RWConfig::history_block(block_number.into()))?;
             tree.get_nonce(account_id.into())?
         }
         None => {
-            let snap = mem_pool_state.load();
-            let tree = snap.state()?;
-            tree.get_nonce(account_id.into())?
+            let state = mem_pool_state.load_state_db();
+            state.get_nonce(account_id.into())?
         }
     };
 
@@ -1661,11 +1652,10 @@ async fn get_script(
     Params((script_hash,)): Params<(JsonH256,)>,
     mem_pool_state: Data<Arc<MemPoolState>>,
 ) -> Result<Option<Script>, RpcError> {
-    let snap = mem_pool_state.load();
-    let tree = snap.state()?;
+    let state = mem_pool_state.load_state_db();
 
     let script_hash = to_h256(script_hash);
-    let script_opt = tree.get_script(&script_hash).map(Into::into);
+    let script_opt = state.get_script(&script_hash).map(Into::into);
 
     Ok(script_opt)
 }
@@ -1674,10 +1664,8 @@ async fn get_script_hash(
     Params((account_id,)): Params<(AccountID,)>,
     mem_pool_state: Data<Arc<MemPoolState>>,
 ) -> Result<JsonH256, RpcError> {
-    let snap = mem_pool_state.load();
-    let tree = snap.state()?;
-
-    let script_hash = tree.get_script_hash(account_id.into())?;
+    let state = mem_pool_state.load_state_db();
+    let script_hash = state.get_script_hash(account_id.into())?;
     Ok(to_jsonh256(script_hash))
 }
 
@@ -1685,12 +1673,11 @@ async fn get_script_hash_by_registry_address(
     Params((serialized_address,)): Params<(JsonBytes,)>,
     mem_pool_state: Data<Arc<MemPoolState>>,
 ) -> Result<Option<JsonH256>, RpcError> {
-    let snap = mem_pool_state.load();
-    let tree = snap.state()?;
+    let state = mem_pool_state.load_state_db();
     let addr =
         gw_common::registry_address::RegistryAddress::from_slice(serialized_address.as_bytes())
             .ok_or_else(|| invalid_param_err("Invalid registry address"))?;
-    let script_hash_opt = tree.get_script_hash_by_registry_address(&addr)?;
+    let script_hash_opt = state.get_script_hash_by_registry_address(&addr)?;
     Ok(script_hash_opt.map(to_jsonh256))
 }
 
@@ -1698,10 +1685,9 @@ async fn get_registry_address_by_script_hash(
     Params((script_hash, registry_id)): Params<(JsonH256, Uint32)>,
     mem_pool_state: Data<Arc<MemPoolState>>,
 ) -> Result<Option<RegistryAddress>, RpcError> {
-    let snap = mem_pool_state.load();
-    let tree = snap.state()?;
+    let state = mem_pool_state.load_state_db();
     let addr =
-        tree.get_registry_address_by_script_hash(registry_id.value(), &to_h256(script_hash))?;
+        state.get_registry_address_by_script_hash(registry_id.value(), &to_h256(script_hash))?;
     Ok(addr.map(Into::into))
 }
 
@@ -1722,10 +1708,8 @@ async fn get_data(
         GetDataParams::Number(p) => p,
     };
 
-    let snap = mem_pool_state.load();
-    let tree = snap.state()?;
-
-    let data_opt = tree
+    let state = mem_pool_state.load_state_db();
+    let data_opt = state
         .get_data(&to_h256(data_hash))
         .map(JsonBytes::from_bytes);
 
@@ -1997,9 +1981,8 @@ async fn get_fee_config(
 async fn get_mem_pool_state_root(
     mem_pool_state: Data<Arc<MemPoolState>>,
 ) -> Result<JsonH256, RpcError> {
-    let snap = mem_pool_state.load();
-    let tree = snap.state()?;
-    let root = tree.calculate_root()?;
+    let state = mem_pool_state.load_state_db();
+    let root = state.last_state_root();
     Ok(to_jsonh256(root))
 }
 
diff --git a/crates/store/src/mem_pool_state.rs b/crates/store/src/mem_pool_state.rs
index cba2ad41a..08006c81d 100644
--- a/crates/store/src/mem_pool_state.rs
+++ b/crates/store/src/mem_pool_state.rs
@@ -1,35 +1,12 @@
-use std::{
-    borrow::Borrow,
-    convert::TryInto,
-    hash::{Hash, Hasher},
-    sync::{
-        atomic::{AtomicBool, Ordering},
-        Arc, RwLock,
-    },
+use std::sync::{
+    atomic::{AtomicBool, Ordering},
+    Arc,
 };
 
-use anyhow::Result;
 use arc_swap::ArcSwap;
-use gw_common::{smt::SMT, H256};
-use gw_db::{
-    error::Error,
-    schema::{Col, COLUMN_ACCOUNT_SMT_BRANCH, COLUMN_ACCOUNT_SMT_LEAF, COLUMN_META},
-};
-use gw_types::{
-    from_box_should_be_ok, packed,
-    prelude::{Entity, FromSliceShouldBeOk, Pack, Unpack},
-};
-use im::HashMap;
+use gw_types::packed::{self, BlockInfo};
 
-use crate::{
-    smt::smt_store::SMTStore,
-    snapshot::StoreSnapshot,
-    state::mem_state_db::MemStateTree,
-    traits::{
-        chain_store::ChainStore,
-        kv_store::{KVStore, KVStoreRead, KVStoreWrite},
-    },
-};
+use crate::state::MemStateDB;
 
 pub const META_MEM_BLOCK_INFO: &[u8] = b"MEM_BLOCK_INFO";
 /// account SMT root
@@ -37,15 +14,24 @@ pub const META_MEM_SMT_ROOT_KEY: &[u8] = b"MEM_ACCOUNT_SMT_ROOT_KEY";
 /// account SMT count
 pub const META_MEM_SMT_COUNT_KEY: &[u8] = b"MEM_ACCOUNT_SMT_COUNT_KEY";
 
+#[derive(Clone)]
+pub struct Shared {
+    pub state_db: MemStateDB,
+    pub mem_block: Option<BlockInfo>,
+}
+
 pub struct MemPoolState {
-    store: ArcSwap<MemStore>,
+    inner: ArcSwap<Shared>,
     completed_initial_syncing: AtomicBool,
 }
 
 impl MemPoolState {
-    pub fn new(store: Arc<MemStore>, completed_initial_syncing: bool) -> Self {
+    pub fn new(state_db: MemStateDB, completed_initial_syncing: bool) -> Self {
         Self {
-            store: ArcSwap::new(store),
+            inner: ArcSwap::new(Arc::new(Shared {
+                state_db,
+                mem_block: None,
+            })),
             completed_initial_syncing: AtomicBool::new(completed_initial_syncing),
         }
     }
@@ -57,192 +43,36 @@ impl MemPoolState {
     ///
     /// Note that updates will not be stored in `MemPoolState` unless you call
     /// [`store`].
-    pub fn load(&self) -> MemStore {
-        MemStore::clone(&self.store.load())
+    pub fn load_state_db(&self) -> MemStateDB {
+        MemStateDB::clone(&self.inner.load().state_db)
     }
 
     /// Replaces the snapshot inside this instance.
-    pub fn store(&self, mem_store: Arc<MemStore>) {
-        self.store.store(mem_store);
-    }
-
-    pub fn completed_initial_syncing(&self) -> bool {
-        self.completed_initial_syncing.load(Ordering::SeqCst)
-    }
-
-    pub fn set_completed_initial_syncing(&self) {
-        self.completed_initial_syncing.store(true, Ordering::SeqCst);
-    }
-}
-
-#[derive(Clone)]
-enum Value<T> {
-    Exist(T),
-    Deleted,
-}
-
-type ColumnsKeyValueMap = HashMap<(u8, Vec<u8>), Value<Vec<u8>>>;
-
-pub struct MemStore {
-    inner: Arc<StoreSnapshot>,
-    // (column, key) -> value.
-    mem: RwLock<ColumnsKeyValueMap>,
-}
-
-impl MemStore {
-    pub fn new(inner: impl Into<Arc<StoreSnapshot>>) -> Self {
-        Self {
-            inner: inner.into(),
-            mem: RwLock::new(HashMap::new()),
-        }
-    }
-
-    pub fn state(&self) -> Result<MemStateTree<'_>> {
-        let merkle_root = {
-            let block = self.get_tip_block()?;
-            block.raw().post_account()
-        };
-        let root = self
-            .get_mem_block_account_smt_root()?
-            .unwrap_or_else(|| merkle_root.merkle_root().unpack());
-        let account_count = self
-            .get_mem_block_account_count()?
-            .unwrap_or_else(|| merkle_root.count().unpack());
-        let mem_smt_store = SMTStore::new(COLUMN_ACCOUNT_SMT_LEAF, COLUMN_ACCOUNT_SMT_BRANCH, self);
-        let tree = SMT::new(root, mem_smt_store);
-        Ok(MemStateTree::new(tree, account_count))
+    pub fn store_state_db(&self, state_db: MemStateDB) {
+        let mut shared = self.load_shared();
+        shared.state_db = state_db;
+        self.store_shared(Arc::new(shared))
     }
 
-    pub fn get_mem_block_account_smt_root(&self) -> Result<Option<H256>, Error> {
-        match self.get(COLUMN_META, META_MEM_SMT_ROOT_KEY) {
-            Some(slice) => {
-                let root: [u8; 32] = slice.as_ref().try_into().unwrap();
-                Ok(Some(root.into()))
-            }
-            None => Ok(None),
-        }
+    pub fn get_mem_pool_block_info(&self) -> Option<packed::BlockInfo> {
+        self.inner.load().mem_block.clone()
     }
 
-    pub fn get_mem_block_account_count(&self) -> Result<Option<u32>, Error> {
-        match self.get(COLUMN_META, META_MEM_SMT_COUNT_KEY) {
-            Some(slice) => Ok(Some(
-                packed::Uint32Reader::from_slice_should_be_ok(&slice).unpack(),
-            )),
-            None => Ok(None),
-        }
+    /// Load shared
+    pub fn load_shared(&self) -> Shared {
+        Shared::clone(&self.inner.load())
     }
 
-    pub fn set_mem_block_account_smt_root(&self, root: H256) -> Result<(), Error> {
-        self.insert_raw(COLUMN_META, META_MEM_SMT_ROOT_KEY, root.as_slice())?;
-        Ok(())
+    /// Store shared
+    pub fn store_shared(&self, shared: Arc<Shared>) {
+        self.inner.store(shared);
     }
 
-    pub fn set_mem_block_account_count(&self, count: u32) -> Result<(), Error> {
-        let count: packed::Uint32 = count.pack();
-        self.insert_raw(COLUMN_META, META_MEM_SMT_COUNT_KEY, count.as_slice())
-            .expect("insert");
-        Ok(())
-    }
-
-    pub fn update_mem_pool_block_info(&self, block_info: &packed::BlockInfo) -> Result<(), Error> {
-        self.insert_raw(COLUMN_META, META_MEM_BLOCK_INFO, block_info.as_slice())
-            .expect("insert");
-        Ok(())
-    }
-
-    pub fn get_mem_pool_block_info(&self) -> Result<Option<packed::BlockInfo>, Error> {
-        match self.get(COLUMN_META, META_MEM_BLOCK_INFO) {
-            Some(slice) => Ok(Some(from_box_should_be_ok!(packed::BlockInfoReader, slice))),
-            None => Ok(None),
-        }
-    }
-}
-
-impl ChainStore for MemStore {}
-
-impl KVStoreRead for MemStore {
-    fn get(&self, col: Col, key: &[u8]) -> Option<Box<[u8]>> {
-        match self
-            .mem
-            .read()
-            .expect("get read lock failed")
-            .get(&(col, key) as &dyn Key)
-        {
-            Some(Value::Exist(v)) => Some(v.clone().into_boxed_slice()),
-            Some(Value::Deleted) => None,
-            None => self.inner.get(col, key),
-        }
-    }
-}
-
-impl KVStoreWrite for MemStore {
-    fn insert_raw(&self, col: Col, key: &[u8], value: &[u8]) -> Result<(), Error> {
-        self.mem
-            .write()
-            .expect("get write lock failed")
-            .insert((col, key.into()), Value::Exist(value.to_vec()));
-        Ok(())
-    }
-
-    fn delete(&self, col: Col, key: &[u8]) -> Result<(), Error> {
-        self.mem
-            .write()
-            .expect("get write lock failed")
-            .insert((col, key.into()), Value::Deleted);
-        Ok(())
-    }
-}
-
-impl KVStore for MemStore {}
-
-impl Clone for MemStore {
-    /// Make a clone of the store. This is cheap.
-    ///
-    /// Modifications on the clone will NOT be seen on this store.
-    fn clone(&self) -> Self {
-        Self {
-            inner: self.inner.clone(),
-            mem: RwLock::new(self.mem.read().unwrap().clone()),
-        }
-    }
-}
-
-// So that we can query a ColumnsKeyValueMap with (u8, &[u8]), without temporary
-// allocation.
-//
-// https://stackoverflow.com/questions/36480845/how-to-avoid-temporary-allocations-when-using-a-complex-key-for-a-hashmap/50478038#50478038
-trait Key {
-    fn to_key(&self) -> (u8, &[u8]);
-}
-
-impl Hash for dyn Key + '_ {
-    fn hash<H: Hasher>(&self, state: &mut H) {
-        self.to_key().hash(state)
-    }
-}
-
-impl PartialEq for dyn Key + '_ {
-    fn eq(&self, other: &Self) -> bool {
-        self.to_key() == other.to_key()
-    }
-}
-
-impl Eq for dyn Key + '_ {}
-
-impl Key for (u8, Vec<u8>) {
-    fn to_key(&self) -> (u8, &[u8]) {
-        (self.0, &self.1[..])
-    }
-}
-
-impl<'a> Key for (u8, &'a [u8]) {
-    fn to_key(&self) -> (u8, &[u8]) {
-        *self
+    pub fn completed_initial_syncing(&self) -> bool {
+        self.completed_initial_syncing.load(Ordering::SeqCst)
     }
-}
 
-impl<'a> Borrow<dyn Key + 'a> for (u8, Vec<u8>) {
-    fn borrow(&self) -> &(dyn Key + 'a) {
-        self
+    pub fn set_completed_initial_syncing(&self) {
+        self.completed_initial_syncing.store(true, Ordering::SeqCst);
     }
 }
diff --git a/crates/store/src/smt/smt_store/mod.rs b/crates/store/src/smt/smt_store/mod.rs
new file mode 100644
index 000000000..3fad13191
--- /dev/null
+++ b/crates/store/src/smt/smt_store/mod.rs
@@ -0,0 +1,7 @@
+pub mod smt_block;
+pub mod smt_reverted_block;
+pub mod smt_state;
+
+pub use smt_block::SMTBlockStore;
+pub use smt_reverted_block::SMTRevertedBlockStore;
+pub use smt_state::SMTStateStore;
diff --git a/crates/store/src/smt/smt_store.rs b/crates/store/src/smt/smt_store/smt_block.rs
similarity index 60%
rename from crates/store/src/smt/smt_store.rs
rename to crates/store/src/smt/smt_store/smt_block.rs
index de2134150..f746691aa 100644
--- a/crates/store/src/smt/smt_store.rs
+++ b/crates/store/src/smt/smt_store/smt_block.rs
@@ -2,8 +2,9 @@
 
 use std::convert::TryInto;
 
-use crate::traits::kv_store::KVStore;
+use crate::traits::{chain_store::ChainStore, kv_store::KVStore};
 use gw_common::{
+    smt::SMT,
     sparse_merkle_tree::{
         error::Error as SMTError,
         traits::Store,
@@ -11,35 +12,34 @@ use gw_common::{
     },
     H256,
 };
-use gw_db::schema::Col;
+use gw_db::schema::{COLUMN_BLOCK_SMT_BRANCH, COLUMN_BLOCK_SMT_LEAF};
 
-use super::serde::{branch_key_to_vec, branch_node_to_vec, slice_to_branch_node};
+use crate::smt::serde::{branch_key_to_vec, branch_node_to_vec, slice_to_branch_node};
 
-pub struct SMTStore<'a, DB: KVStore> {
-    leaf_col: Col,
-    branch_col: Col,
-    store: &'a DB,
+pub struct SMTBlockStore<DB: KVStore>(DB);
+
+impl<DB: KVStore + ChainStore> SMTBlockStore<DB> {
+    pub fn to_smt(self) -> anyhow::Result<SMT<Self>> {
+        let root = self.inner_store().get_block_smt_root()?;
+        Ok(SMT::new(root, self))
+    }
 }
 
-impl<'a, DB: KVStore> SMTStore<'a, DB> {
-    pub fn new(leaf_col: Col, branch_col: Col, store: &'a DB) -> Self {
-        SMTStore {
-            leaf_col,
-            branch_col,
-            store,
-        }
+impl<DB: KVStore> SMTBlockStore<DB> {
+    pub fn new(store: DB) -> Self {
+        SMTBlockStore(store)
     }
 
     pub fn inner_store(&self) -> &DB {
-        self.store
+        &self.0
     }
 }
 
-impl<'a, DB: KVStore> Store<H256> for SMTStore<'a, DB> {
+impl<DB: KVStore> Store<H256> for SMTBlockStore<DB> {
     fn get_branch(&self, branch_key: &BranchKey) -> Result<Option<BranchNode>, SMTError> {
         match self
-            .store
-            .get(self.branch_col, &branch_key_to_vec(branch_key))
+            .0
+            .get(COLUMN_BLOCK_SMT_BRANCH, &branch_key_to_vec(branch_key))
         {
             Some(slice) => Ok(Some(slice_to_branch_node(&slice))),
             None => Ok(None),
@@ -47,7 +47,7 @@ impl<'a, DB: KVStore> Store<H256> for SMTStore<'a, DB> {
     }
 
     fn get_leaf(&self, leaf_key: &H256) -> Result<Option<H256>, SMTError> {
-        match self.store.get(self.leaf_col, leaf_key.as_slice()) {
+        match self.0.get(COLUMN_BLOCK_SMT_LEAF, leaf_key.as_slice()) {
             Some(slice) if 32 == slice.len() => {
                 let leaf: [u8; 32] = slice.as_ref().try_into().unwrap();
                 Ok(Some(H256::from(leaf)))
@@ -58,9 +58,9 @@ impl<'a, DB: KVStore> Store<H256> for SMTStore<'a, DB> {
     }
 
     fn insert_branch(&mut self, branch_key: BranchKey, branch: BranchNode) -> Result<(), SMTError> {
-        self.store
+        self.0
             .insert_raw(
-                self.branch_col,
+                COLUMN_BLOCK_SMT_BRANCH,
                 &branch_key_to_vec(&branch_key),
                 &branch_node_to_vec(&branch),
             )
@@ -70,24 +70,24 @@ impl<'a, DB: KVStore> Store<H256> for SMTStore<'a, DB> {
     }
 
     fn insert_leaf(&mut self, leaf_key: H256, leaf: H256) -> Result<(), SMTError> {
-        self.store
-            .insert_raw(self.leaf_col, leaf_key.as_slice(), leaf.as_slice())
+        self.0
+            .insert_raw(COLUMN_BLOCK_SMT_LEAF, leaf_key.as_slice(), leaf.as_slice())
             .map_err(|err| SMTError::Store(format!("insert error {}", err)))?;
 
         Ok(())
     }
 
     fn remove_branch(&mut self, branch_key: &BranchKey) -> Result<(), SMTError> {
-        self.store
-            .delete(self.branch_col, &branch_key_to_vec(branch_key))
+        self.0
+            .delete(COLUMN_BLOCK_SMT_BRANCH, &branch_key_to_vec(branch_key))
             .map_err(|err| SMTError::Store(format!("delete error {}", err)))?;
 
         Ok(())
     }
 
     fn remove_leaf(&mut self, leaf_key: &H256) -> Result<(), SMTError> {
-        self.store
-            .delete(self.leaf_col, leaf_key.as_slice())
+        self.0
+            .delete(COLUMN_BLOCK_SMT_LEAF, leaf_key.as_slice())
             .map_err(|err| SMTError::Store(format!("delete error {}", err)))?;
 
         Ok(())
diff --git a/crates/store/src/smt/smt_store/smt_reverted_block.rs b/crates/store/src/smt/smt_store/smt_reverted_block.rs
new file mode 100644
index 000000000..ad78a73a1
--- /dev/null
+++ b/crates/store/src/smt/smt_store/smt_reverted_block.rs
@@ -0,0 +1,105 @@
+//! Implement SMTStore trait
+
+use std::convert::TryInto;
+
+use crate::traits::{chain_store::ChainStore, kv_store::KVStore};
+use gw_common::{
+    smt::SMT,
+    sparse_merkle_tree::{
+        error::Error as SMTError,
+        traits::Store,
+        tree::{BranchKey, BranchNode},
+    },
+    H256,
+};
+use gw_db::schema::{COLUMN_REVERTED_BLOCK_SMT_BRANCH, COLUMN_REVERTED_BLOCK_SMT_LEAF};
+
+use crate::smt::serde::{branch_key_to_vec, branch_node_to_vec, slice_to_branch_node};
+
+pub struct SMTRevertedBlockStore<DB>(DB);
+
+impl<DB: KVStore + ChainStore> SMTRevertedBlockStore<DB> {
+    pub fn to_smt(self) -> anyhow::Result<SMT<Self>> {
+        let root = self.inner_store().get_reverted_block_smt_root()?;
+        Ok(SMT::new(root, self))
+    }
+}
+
+impl<DB: KVStore> SMTRevertedBlockStore<DB> {
+    pub fn new(store: DB) -> Self {
+        SMTRevertedBlockStore(store)
+    }
+
+    pub fn inner_store(&self) -> &DB {
+        &self.0
+    }
+}
+
+impl<DB: KVStore> Store<H256> for SMTRevertedBlockStore<DB> {
+    fn get_branch(&self, branch_key: &BranchKey) -> Result<Option<BranchNode>, SMTError> {
+        match self.0.get(
+            COLUMN_REVERTED_BLOCK_SMT_BRANCH,
+            &branch_key_to_vec(branch_key),
+        ) {
+            Some(slice) => Ok(Some(slice_to_branch_node(&slice))),
+            None => Ok(None),
+        }
+    }
+
+    fn get_leaf(&self, leaf_key: &H256) -> Result<Option<H256>, SMTError> {
+        match self
+            .0
+            .get(COLUMN_REVERTED_BLOCK_SMT_LEAF, leaf_key.as_slice())
+        {
+            Some(slice) if 32 == slice.len() => {
+                let leaf: [u8; 32] = slice.as_ref().try_into().unwrap();
+                Ok(Some(H256::from(leaf)))
+            }
+            Some(_) => Err(SMTError::Store("get corrupted leaf".to_string())),
+            None => Ok(None),
+        }
+    }
+
+    fn insert_branch(&mut self, branch_key: BranchKey, branch: BranchNode) -> Result<(), SMTError> {
+        self.0
+            .insert_raw(
+                COLUMN_REVERTED_BLOCK_SMT_BRANCH,
+                &branch_key_to_vec(&branch_key),
+                &branch_node_to_vec(&branch),
+            )
+            .map_err(|err| SMTError::Store(format!("insert error {}", err)))?;
+
+        Ok(())
+    }
+
+    fn insert_leaf(&mut self, leaf_key: H256, leaf: H256) -> Result<(), SMTError> {
+        self.0
+            .insert_raw(
+                COLUMN_REVERTED_BLOCK_SMT_LEAF,
+                leaf_key.as_slice(),
+                leaf.as_slice(),
+            )
+            .map_err(|err| SMTError::Store(format!("insert error {}", err)))?;
+
+        Ok(())
+    }
+
+    fn remove_branch(&mut self, branch_key: &BranchKey) -> Result<(), SMTError> {
+        self.0
+            .delete(
+                COLUMN_REVERTED_BLOCK_SMT_BRANCH,
+                &branch_key_to_vec(branch_key),
+            )
+            .map_err(|err| SMTError::Store(format!("delete error {}", err)))?;
+
+        Ok(())
+    }
+
+    fn remove_leaf(&mut self, leaf_key: &H256) -> Result<(), SMTError> {
+        self.0
+            .delete(COLUMN_REVERTED_BLOCK_SMT_LEAF, leaf_key.as_slice())
+            .map_err(|err| SMTError::Store(format!("delete error {}", err)))?;
+
+        Ok(())
+    }
+}
diff --git a/crates/store/src/smt/smt_store/smt_state.rs b/crates/store/src/smt/smt_store/smt_state.rs
new file mode 100644
index 000000000..270185ff2
--- /dev/null
+++ b/crates/store/src/smt/smt_store/smt_state.rs
@@ -0,0 +1,116 @@
+//! Implement SMTStore trait
+
+use std::convert::TryInto;
+
+use crate::traits::{chain_store::ChainStore, kv_store::KVStore};
+use gw_common::{
+    smt::SMT,
+    sparse_merkle_tree::{
+        error::Error as SMTError,
+        traits::Store,
+        tree::{BranchKey, BranchNode},
+    },
+    H256,
+};
+use gw_db::schema::{COLUMN_ACCOUNT_SMT_BRANCH, COLUMN_ACCOUNT_SMT_LEAF};
+use gw_types::prelude::Unpack;
+
+use crate::smt::serde::{branch_key_to_vec, branch_node_to_vec, slice_to_branch_node};
+
+pub struct SMTStateStore<DB>(DB);
+
+impl<DB: Clone> Clone for SMTStateStore<DB> {
+    fn clone(&self) -> Self {
+        Self(self.0.clone())
+    }
+}
+
+impl<DB: KVStore + ChainStore> SMTStateStore<DB> {
+    pub fn to_smt(self) -> anyhow::Result<SMT<Self>> {
+        let root = self
+            .inner_store()
+            .get_last_valid_tip_block()?
+            .raw()
+            .post_account()
+            .merkle_root()
+            .unpack();
+        Ok(SMT::new(root, self))
+    }
+}
+
+impl<DB: KVStore> SMTStateStore<DB> {
+    pub fn new(store: DB) -> Self {
+        Self(store)
+    }
+
+    pub fn inner_store(&self) -> &DB {
+        &self.0
+    }
+
+    pub fn inner_store_mut(&mut self) -> &mut DB {
+        &mut self.0
+    }
+}
+
+impl<DB: KVStore> Store<H256> for SMTStateStore<DB> {
+    fn get_branch(&self, branch_key: &BranchKey) -> Result<Option<BranchNode>, SMTError> {
+        match self
+            .0
+            .get(COLUMN_ACCOUNT_SMT_BRANCH, &branch_key_to_vec(branch_key))
+        {
+            Some(slice) => Ok(Some(slice_to_branch_node(&slice))),
+            None => Ok(None),
+        }
+    }
+
+    fn get_leaf(&self, leaf_key: &H256) -> Result<Option<H256>, SMTError> {
+        match self.0.get(COLUMN_ACCOUNT_SMT_LEAF, leaf_key.as_slice()) {
+            Some(slice) if 32 == slice.len() => {
+                let leaf: [u8; 32] = slice.as_ref().try_into().unwrap();
+                Ok(Some(H256::from(leaf)))
+            }
+            Some(_) => Err(SMTError::Store("get corrupted leaf".to_string())),
+            None => Ok(None),
+        }
+    }
+
+    fn insert_branch(&mut self, branch_key: BranchKey, branch: BranchNode) -> Result<(), SMTError> {
+        self.0
+            .insert_raw(
+                COLUMN_ACCOUNT_SMT_BRANCH,
+                &branch_key_to_vec(&branch_key),
+                &branch_node_to_vec(&branch),
+            )
+            .map_err(|err| SMTError::Store(format!("insert error {}", err)))?;
+
+        Ok(())
+    }
+
+    fn insert_leaf(&mut self, leaf_key: H256, leaf: H256) -> Result<(), SMTError> {
+        self.0
+            .insert_raw(
+                COLUMN_ACCOUNT_SMT_LEAF,
+                leaf_key.as_slice(),
+                leaf.as_slice(),
+            )
+            .map_err(|err| SMTError::Store(format!("insert error {}", err)))?;
+
+        Ok(())
+    }
+
+    fn remove_branch(&mut self, branch_key: &BranchKey) -> Result<(), SMTError> {
+        self.0
+            .delete(COLUMN_ACCOUNT_SMT_BRANCH, &branch_key_to_vec(branch_key))
+            .map_err(|err| SMTError::Store(format!("delete error {}", err)))?;
+
+        Ok(())
+    }
+
+    fn remove_leaf(&mut self, leaf_key: &H256) -> Result<(), SMTError> {
+        self.0
+            .delete(COLUMN_ACCOUNT_SMT_LEAF, leaf_key.as_slice())
+            .map_err(|err| SMTError::Store(format!("delete error {}", err)))?;
+
+        Ok(())
+    }
+}
diff --git a/crates/store/src/snapshot.rs b/crates/store/src/snapshot.rs
index d89657e10..7650141c3 100644
--- a/crates/store/src/snapshot.rs
+++ b/crates/store/src/snapshot.rs
@@ -3,7 +3,10 @@ use gw_db::{
     DBIterator, RocksDBSnapshot,
 };
 
-use crate::traits::{chain_store::ChainStore, kv_store::KVStoreRead};
+use crate::traits::{
+    chain_store::ChainStore,
+    kv_store::{KVStore, KVStoreRead, KVStoreWrite},
+};
 
 pub struct StoreSnapshot {
     inner: RocksDBSnapshot,
@@ -26,6 +29,19 @@ impl KVStoreRead for StoreSnapshot {
     }
 }
 
+/// We implement the write for snapshot for readonly operations
+impl KVStoreWrite for StoreSnapshot {
+    fn insert_raw(&self, _col: Col, _key: &[u8], _value: &[u8]) -> Result<(), gw_db::error::Error> {
+        Err("Can't write to snapshot".to_string().into())
+    }
+
+    fn delete(&self, _col: Col, _key: &[u8]) -> Result<(), gw_db::error::Error> {
+        Err("Can't delete key from snapshot".to_string().into())
+    }
+}
+
+impl KVStore for StoreSnapshot {}
+
 impl StoreSnapshot {
     pub fn iter_mem_pool_transactions(&self) -> impl Iterator<Item = Box<[u8]>> + '_ {
         self.inner
diff --git a/crates/store/src/state/block_state_record.rs b/crates/store/src/state/history/block_state_record.rs
similarity index 100%
rename from crates/store/src/state/block_state_record.rs
rename to crates/store/src/state/history/block_state_record.rs
diff --git a/crates/store/src/state/history/history_state.rs b/crates/store/src/state/history/history_state.rs
new file mode 100644
index 000000000..7b2ec7963
--- /dev/null
+++ b/crates/store/src/state/history/history_state.rs
@@ -0,0 +1,247 @@
+//! State DB
+
+use anyhow::Result;
+use gw_common::{error::Error as StateError, smt::SMT, state::State, H256};
+use gw_traits::CodeStore;
+use gw_types::{
+    bytes::Bytes,
+    packed::{self, AccountMerkleState, Byte32},
+    prelude::*,
+};
+use log::log_enabled;
+
+use crate::{
+    smt::smt_store::SMTStateStore, state::history::block_state_record::BlockStateRecordKey,
+    traits::kv_store::KVStore,
+};
+
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+pub enum ReadOpt {
+    Block(u64),
+    Any,
+}
+
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+pub enum WriteOpt {
+    NoRecord,
+    Block(u64),
+    Deny,
+}
+
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+pub struct RWConfig {
+    read: ReadOpt,
+    write: WriteOpt,
+}
+
+impl RWConfig {
+    pub fn readonly() -> Self {
+        RWConfig {
+            read: ReadOpt::Any,
+            write: WriteOpt::Deny,
+        }
+    }
+
+    pub fn attach_block(number: u64) -> Self {
+        RWConfig {
+            read: ReadOpt::Any,
+            write: WriteOpt::Block(number),
+        }
+    }
+
+    pub fn detach_block() -> Self {
+        RWConfig {
+            read: ReadOpt::Any,
+            write: WriteOpt::NoRecord,
+        }
+    }
+
+    pub fn history_block(number: u64) -> Self {
+        RWConfig {
+            read: ReadOpt::Block(number),
+            write: WriteOpt::Deny,
+        }
+    }
+}
+
+pub trait HistoryStateStore {
+    type BlockStateRecordKeyIter: IntoIterator<Item = BlockStateRecordKey>;
+    fn iter_block_state_record(&self, block_number: u64) -> Self::BlockStateRecordKeyIter;
+    fn remove_block_state_record(&self, block_number: u64) -> Result<(), anyhow::Error>;
+    fn get_history_state(&self, block_number: u64, state_key: &H256) -> Option<H256>;
+    fn record_block_state(
+        &self,
+        block_number: u64,
+        state_key: H256,
+        value: H256,
+    ) -> Result<(), anyhow::Error>;
+}
+
+pub struct HistoryState<TreeStore> {
+    account_count: u32,
+    tree: SMT<SMTStateStore<TreeStore>>,
+    rw_config: RWConfig,
+}
+
+impl<Store: Clone + KVStore> Clone for HistoryState<Store> {
+    fn clone(&self) -> Self {
+        Self {
+            account_count: self.account_count,
+            tree: SMT::new(*self.tree.root(), self.tree.store().clone()),
+            rw_config: self.rw_config,
+        }
+    }
+}
+
+impl<Store: HistoryStateStore + CodeStore + KVStore> HistoryState<Store> {
+    pub fn new(tree: SMT<SMTStateStore<Store>>, account_count: u32, rw_config: RWConfig) -> Self {
+        Self {
+            tree,
+            account_count,
+            rw_config,
+        }
+    }
+
+    pub fn get_merkle_state(&self) -> AccountMerkleState {
+        AccountMerkleState::new_builder()
+            .merkle_root(self.tree.root().pack())
+            .count(self.account_count.pack())
+            .build()
+    }
+
+    /// Detach block state from state tree
+    pub fn detach_block_state(&mut self, block_number: u64) -> Result<()> {
+        // reset states to previous value
+        let parent_block_number = block_number.saturating_sub(1);
+        let reverted_key_values: Vec<_> = self
+            .db()
+            .iter_block_state_record(block_number)
+            .into_iter()
+            .map(|record_key| {
+                let state_key = record_key.state_key();
+                let last_value = self
+                    .db()
+                    .get_history_state(parent_block_number, &state_key)
+                    .unwrap_or_else(H256::zero);
+                (state_key, last_value)
+            })
+            .collect();
+        for (state_key, last_value) in reverted_key_values {
+            self.update_raw(state_key, last_value)?;
+        }
+
+        // remove block's state record
+        self.db().remove_block_state_record(block_number)?;
+
+        Ok(())
+    }
+
+    fn db(&self) -> &Store {
+        self.tree.store().inner_store()
+    }
+
+    fn db_mut(&mut self) -> &mut Store {
+        self.tree.store_mut().inner_store_mut()
+    }
+}
+
+impl<Store: KVStore + HistoryStateStore + CodeStore> State for HistoryState<Store> {
+    fn get_raw(&self, key: &H256) -> Result<H256, StateError> {
+        let v = match self.rw_config.read {
+            ReadOpt::Block(block_number) => self
+                .db()
+                .get_history_state(block_number, key)
+                .unwrap_or_default(),
+            _ => self.tree.get(key)?,
+        };
+        if log_enabled!(log::Level::Trace) {
+            let k: Byte32 = key.pack();
+            let v: Byte32 = v.pack();
+            log::trace!(
+                "[state-trace] get_raw rw_config:{:?} k:{} v:{}",
+                self.rw_config,
+                k,
+                v
+            );
+        }
+        Ok(v)
+    }
+
+    fn update_raw(&mut self, key: H256, value: H256) -> Result<(), StateError> {
+        self.tree.update(key, value)?;
+        // record block's kv state
+        match self.rw_config.write {
+            WriteOpt::Block(block_number) => {
+                self.db()
+                    .record_block_state(block_number, key, value)
+                    .expect("record block state");
+            }
+            WriteOpt::NoRecord => {
+                // skip record history state, dettach block may use this config
+            }
+            WriteOpt::Deny => {
+                // deny write
+                return Err(StateError::Store);
+            }
+        }
+        if log_enabled!(log::Level::Trace) {
+            let k: Byte32 = key.pack();
+            let v: Byte32 = value.pack();
+            log::trace!(
+                "[state-trace] update_raw rw_config:{:?} k:{} v:{}",
+                self.rw_config,
+                k,
+                v
+            );
+        }
+        Ok(())
+    }
+
+    fn get_account_count(&self) -> Result<u32, StateError> {
+        if log_enabled!(log::Level::Trace) {
+            log::trace!(
+                "[state-trace] get_account_count rw_config:{:?} count:{}",
+                self.rw_config,
+                self.account_count
+            );
+        }
+        Ok(self.account_count)
+    }
+
+    fn set_account_count(&mut self, count: u32) -> Result<(), StateError> {
+        if log_enabled!(log::Level::Trace) {
+            log::trace!(
+                "[state-trace] set_account_count rw_config:{:?} origin: {} count:{}",
+                self.rw_config,
+                self.account_count,
+                count
+            );
+        }
+        self.account_count = count;
+        Ok(())
+    }
+
+    fn finalise_root(&mut self) -> Result<H256, StateError> {
+        let root = self.tree.root();
+        Ok(*root)
+    }
+}
+
+/// TODO Store scripts and data by block height
+impl<Store: KVStore + HistoryStateStore + CodeStore> CodeStore for HistoryState<Store> {
+    fn insert_script(&mut self, script_hash: H256, script: packed::Script) {
+        self.db_mut().insert_script(script_hash, script)
+    }
+
+    fn get_script(&self, script_hash: &H256) -> Option<packed::Script> {
+        self.db().get_script(script_hash)
+    }
+
+    fn insert_data(&mut self, data_hash: H256, code: Bytes) {
+        self.db_mut().insert_data(data_hash, code)
+    }
+
+    fn get_data(&self, data_hash: &H256) -> Option<Bytes> {
+        self.db().get_data(data_hash)
+    }
+}
diff --git a/crates/store/src/state/history/mod.rs b/crates/store/src/state/history/mod.rs
new file mode 100644
index 000000000..2f0931bee
--- /dev/null
+++ b/crates/store/src/state/history/mod.rs
@@ -0,0 +1,2 @@
+pub mod block_state_record;
+pub mod history_state;
diff --git a/crates/store/src/state/mod.rs b/crates/store/src/state/mod.rs
index b31faae69..f118f1f81 100644
--- a/crates/store/src/state/mod.rs
+++ b/crates/store/src/state/mod.rs
@@ -1,4 +1,14 @@
-pub mod block_state_record;
-pub mod mem_state_db;
+//! State
+//!
+//! - state_db: the wrapper of all state layers
+//! - overlay: memory overlay layer
+//! - history: history block state layer
+
+pub mod history;
+pub mod overlay;
 pub mod state_db;
-mod state_tracker;
+pub mod traits;
+
+// alias types
+pub type MemStateDB = state_db::StateDB<overlay::mem_state::MemStateTree>;
+pub type BlockStateDB<S> = state_db::StateDB<history::history_state::HistoryState<S>>;
diff --git a/crates/store/src/state/mem_state_db.rs b/crates/store/src/state/overlay/mem_state.rs
similarity index 56%
rename from crates/store/src/state/mem_state_db.rs
rename to crates/store/src/state/overlay/mem_state.rs
index c326ad315..c5f078cd2 100644
--- a/crates/store/src/state/mem_state_db.rs
+++ b/crates/store/src/state/overlay/mem_state.rs
@@ -1,8 +1,9 @@
-//! State DB
+//! Mem State DB
+//!
 
-use crate::mem_pool_state::MemStore;
+use crate::smt::smt_store::SMTStateStore;
 use crate::traits::kv_store::KVStoreRead;
-use crate::{smt::smt_store::SMTStore, traits::kv_store::KVStoreWrite};
+use crate::traits::kv_store::KVStoreWrite;
 use anyhow::Result;
 use gw_common::{error::Error as StateError, smt::SMT, state::State, H256};
 use gw_db::schema::{COLUMN_DATA, COLUMN_SCRIPT};
@@ -14,27 +15,21 @@ use gw_types::{
     prelude::*,
 };
 
-use super::state_tracker::StateTracker;
+use super::mem_store::MemStore;
 
-pub struct MemStateTree<'a> {
-    tree: SMT<SMTStore<'a, MemStore>>,
+pub struct MemStateTree {
+    tree: SMT<SMTStateStore<MemStore>>,
     account_count: u32,
-    tracker: StateTracker,
 }
 
-impl<'a> MemStateTree<'a> {
-    pub fn new(tree: SMT<SMTStore<'a, MemStore>>, account_count: u32) -> Self {
+impl MemStateTree {
+    pub fn new(tree: SMT<SMTStateStore<MemStore>>, account_count: u32) -> Self {
         MemStateTree {
             tree,
             account_count,
-            tracker: Default::default(),
         }
     }
 
-    pub fn tracker_mut(&mut self) -> &mut StateTracker {
-        &mut self.tracker
-    }
-
     pub fn get_merkle_state(&self) -> AccountMerkleState {
         AccountMerkleState::new_builder()
             .merkle_root(self.tree.root().pack())
@@ -42,35 +37,42 @@ impl<'a> MemStateTree<'a> {
             .build()
     }
 
-    pub fn smt(&self) -> &SMT<SMTStore<'a, MemStore>> {
+    pub fn smt(&self) -> &SMT<SMTStateStore<MemStore>> {
         &self.tree
     }
 
-    /// submit tree changes into memory block
-    /// notice, this function do not commit the DBTransaction
-    pub fn submit_tree_to_mem_block(&self) {
-        self.db()
-            .set_mem_block_account_smt_root(*self.tree.root())
-            .expect("set smt root");
-        self.db()
-            .set_mem_block_account_count(self.account_count)
-            .expect("set smt root");
+    // /// submit tree changes into memory block
+    // /// notice, this function do not commit the DBTransaction
+    // pub fn submit_tree_to_mem_block(&self) {
+    //     self.db()
+    //         .set_mem_block_account_smt_root(*self.tree.root())
+    //         .expect("set smt root");
+    //     self.db()
+    //         .set_mem_block_account_count(self.account_count)
+    //         .expect("set smt root");
+    // }
+
+    fn db(&self) -> &SMTStateStore<MemStore> {
+        self.tree.store()
     }
+}
 
-    fn db(&self) -> &MemStore {
-        self.tree.store().inner_store()
+impl Clone for MemStateTree {
+    fn clone(&self) -> Self {
+        Self {
+            tree: SMT::new(*self.tree.root(), self.tree.store().clone()),
+            account_count: self.account_count,
+        }
     }
 }
 
-impl<'a> State for MemStateTree<'a> {
+impl State for MemStateTree {
     fn get_raw(&self, key: &H256) -> Result<H256, StateError> {
-        self.tracker.touch_key(key);
         let v = self.tree.get(key)?;
         Ok(v)
     }
 
     fn update_raw(&mut self, key: H256, value: H256) -> Result<(), StateError> {
-        self.tracker.touch_key(&key);
         self.tree.update(key, value)?;
         Ok(())
     }
@@ -84,36 +86,48 @@ impl<'a> State for MemStateTree<'a> {
         Ok(())
     }
 
-    fn calculate_root(&self) -> Result<H256, StateError> {
+    fn finalise_root(&mut self) -> Result<H256, StateError> {
         let root = self.tree.root();
         Ok(*root)
     }
 }
 
-impl<'a> CodeStore for MemStateTree<'a> {
+impl CodeStore for MemStateTree {
     fn insert_script(&mut self, script_hash: H256, script: packed::Script) {
         self.db()
+            .inner_store()
             .insert_raw(COLUMN_SCRIPT, script_hash.as_slice(), script.as_slice())
             .expect("insert script");
     }
 
     fn get_script(&self, script_hash: &H256) -> Option<packed::Script> {
         self.db()
+            .inner_store()
             .get(COLUMN_SCRIPT, script_hash.as_slice())
-            .or_else(|| self.db().get(COLUMN_SCRIPT, script_hash.as_slice()))
+            .or_else(|| {
+                self.db()
+                    .inner_store()
+                    .get(COLUMN_SCRIPT, script_hash.as_slice())
+            })
             .map(|slice| from_box_should_be_ok!(packed::ScriptReader, slice))
     }
 
     fn insert_data(&mut self, data_hash: H256, code: Bytes) {
         self.db()
+            .inner_store()
             .insert_raw(COLUMN_DATA, data_hash.as_slice(), &code)
             .expect("insert data");
     }
 
     fn get_data(&self, data_hash: &H256) -> Option<Bytes> {
         self.db()
+            .inner_store()
             .get(COLUMN_DATA, data_hash.as_slice())
-            .or_else(|| self.db().get(COLUMN_DATA, data_hash.as_slice()))
+            .or_else(|| {
+                self.db()
+                    .inner_store()
+                    .get(COLUMN_DATA, data_hash.as_slice())
+            })
             .map(|slice| Bytes::from(slice.to_vec()))
     }
 }
diff --git a/crates/store/src/state/overlay/mem_store.rs b/crates/store/src/state/overlay/mem_store.rs
new file mode 100644
index 000000000..e840e370b
--- /dev/null
+++ b/crates/store/src/state/overlay/mem_store.rs
@@ -0,0 +1,161 @@
+use std::{
+    borrow::Borrow,
+    hash::{Hash, Hasher},
+    sync::{Arc, RwLock},
+};
+
+use anyhow::Result;
+use gw_common::H256;
+use gw_db::{
+    error::Error,
+    schema::{Col, COLUMN_DATA, COLUMN_SCRIPT},
+};
+use gw_traits::CodeStore;
+use gw_types::{
+    bytes::Bytes,
+    from_box_should_be_ok, packed,
+    prelude::{Entity, FromSliceShouldBeOk},
+};
+use im::HashMap;
+
+use crate::{
+    snapshot::StoreSnapshot,
+    traits::{
+        chain_store::ChainStore,
+        kv_store::{KVStore, KVStoreRead, KVStoreWrite},
+    },
+};
+
+#[derive(Clone, PartialEq, Eq, Debug)]
+enum Value<T> {
+    Exist(T),
+    Deleted,
+}
+
+type ColumnsKeyValueMap = HashMap<(u8, Vec<u8>), Value<Vec<u8>>>;
+
+pub struct MemStore {
+    inner: Arc<StoreSnapshot>,
+    // (column, key) -> value.
+    mem: RwLock<ColumnsKeyValueMap>,
+}
+
+impl MemStore {
+    pub fn new(inner: impl Into<Arc<StoreSnapshot>>) -> Self {
+        Self {
+            inner: inner.into(),
+            mem: RwLock::new(HashMap::new()),
+        }
+    }
+}
+
+impl ChainStore for MemStore {}
+
+impl CodeStore for MemStore {
+    fn insert_script(&mut self, script_hash: H256, script: packed::Script) {
+        self.insert_raw(COLUMN_SCRIPT, script_hash.as_slice(), script.as_slice())
+            .expect("insert script")
+    }
+
+    fn get_script(&self, script_hash: &H256) -> Option<packed::Script> {
+        self.get(COLUMN_SCRIPT, script_hash.as_slice())
+            .map(|slice| from_box_should_be_ok!(packed::ScriptReader, slice))
+    }
+
+    fn insert_data(&mut self, data_hash: H256, code: gw_types::bytes::Bytes) {
+        self.insert_raw(COLUMN_DATA, data_hash.as_slice(), &code)
+            .expect("insert data");
+    }
+
+    fn get_data(&self, data_hash: &H256) -> Option<gw_types::bytes::Bytes> {
+        self.get(COLUMN_DATA, data_hash.as_slice())
+            .map(|slice| Bytes::from(slice.to_vec()))
+    }
+}
+
+impl KVStoreRead for MemStore {
+    fn get(&self, col: Col, key: &[u8]) -> Option<Box<[u8]>> {
+        match self
+            .mem
+            .read()
+            .expect("get read lock failed")
+            .get(&(col, key) as &dyn Key)
+        {
+            Some(Value::Exist(v)) => Some(v.clone().into_boxed_slice()),
+            Some(Value::Deleted) => None,
+            None => self.inner.get(col, key),
+        }
+    }
+}
+
+impl KVStoreWrite for MemStore {
+    fn insert_raw(&self, col: Col, key: &[u8], value: &[u8]) -> Result<(), Error> {
+        self.mem
+            .write()
+            .expect("get write lock failed")
+            .insert((col, key.into()), Value::Exist(value.to_vec()));
+        Ok(())
+    }
+
+    fn delete(&self, col: Col, key: &[u8]) -> Result<(), Error> {
+        self.mem
+            .write()
+            .expect("get write lock failed")
+            .insert((col, key.into()), Value::Deleted);
+        Ok(())
+    }
+}
+
+impl KVStore for MemStore {}
+
+impl Clone for MemStore {
+    /// Make a clone of the store. This is cheap.
+    ///
+    /// Modifications on the clone will NOT be seen on this store.
+    fn clone(&self) -> Self {
+        Self {
+            inner: self.inner.clone(),
+            mem: RwLock::new(self.mem.read().unwrap().clone()),
+        }
+    }
+}
+
+// So that we can query a ColumnsKeyValueMap with (u8, &[u8]), without temporary
+// allocation.
+//
+// https://stackoverflow.com/questions/36480845/how-to-avoid-temporary-allocations-when-using-a-complex-key-for-a-hashmap/50478038#50478038
+trait Key {
+    fn to_key(&self) -> (u8, &[u8]);
+}
+
+impl Hash for dyn Key + '_ {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.to_key().hash(state)
+    }
+}
+
+impl PartialEq for dyn Key + '_ {
+    fn eq(&self, other: &Self) -> bool {
+        self.to_key() == other.to_key()
+    }
+}
+
+impl Eq for dyn Key + '_ {}
+
+impl Key for (u8, Vec<u8>) {
+    fn to_key(&self) -> (u8, &[u8]) {
+        (self.0, &self.1[..])
+    }
+}
+
+impl<'a> Key for (u8, &'a [u8]) {
+    fn to_key(&self) -> (u8, &[u8]) {
+        *self
+    }
+}
+
+impl<'a> Borrow<dyn Key + 'a> for (u8, Vec<u8>) {
+    fn borrow(&self) -> &(dyn Key + 'a) {
+        self
+    }
+}
diff --git a/crates/store/src/state/overlay/mod.rs b/crates/store/src/state/overlay/mod.rs
new file mode 100644
index 000000000..60c302064
--- /dev/null
+++ b/crates/store/src/state/overlay/mod.rs
@@ -0,0 +1,2 @@
+pub mod mem_state;
+pub mod mem_store;
diff --git a/crates/store/src/state/state_db.rs b/crates/store/src/state/state_db.rs
index ec5d6d587..7ee05057e 100644
--- a/crates/store/src/state/state_db.rs
+++ b/crates/store/src/state/state_db.rs
@@ -1,60 +1,240 @@
-//! State DB
+//! StateDB
+//!
+//! StateDB is build in layers, for example:
+//!
+//! - StateDB (maintain in-memory journal and snapshot)
+//! - HistoryState (persist histories block state)
+//! - FileDB (RocksDB)
+//!
+
+use std::{collections::HashSet, sync::Mutex};
 
-use crate::{
-    smt::smt_store::SMTStore,
-    traits::kv_store::{KVStoreRead, KVStoreWrite},
-    transaction::StoreTransaction,
-};
 use anyhow::{anyhow, Result};
-use gw_common::{error::Error as StateError, smt::SMT, state::State, H256};
-use gw_db::schema::{COLUMN_DATA, COLUMN_SCRIPT};
 use gw_traits::CodeStore;
 use gw_types::{
     bytes::Bytes,
-    from_box_should_be_ok,
-    packed::{self, AccountMerkleState, Byte32},
-    prelude::*,
+    packed,
+    prelude::{Pack, Unpack},
+};
+
+use gw_common::{error::Error as StateError, smt::SMT, state::State, H256};
+
+use crate::{
+    smt::smt_store::SMTStateStore,
+    snapshot::StoreSnapshot,
+    state::history::history_state::{HistoryState, HistoryStateStore},
+    traits::{chain_store::ChainStore, kv_store::KVStore},
+};
+
+use super::{
+    history::history_state::RWConfig,
+    overlay::{mem_state::MemStateTree, mem_store::MemStore},
+    BlockStateDB, MemStateDB,
 };
-use log::log_enabled;
-#[derive(Debug, PartialEq, Eq, Clone, Copy)]
-pub enum StateContext {
-    ReadOnly,
-    ReadOnlyHistory(u64),
-    AttachBlock(u64),
-    DetachBlock(u64),
+
+#[derive(Debug, Clone)]
+pub enum JournalEntry {
+    UpdateRaw { key: H256, prev_value: H256 },
+    SetAccountCount { prev_count: u32 },
+    InsertScript { script_hash: H256, prev_exist: bool },
+    InsertData { data_hash: H256, prev_exist: bool },
 }
 
-pub struct StateTree<'a> {
-    tree: SMT<SMTStore<'a, StoreTransaction>>,
-    account_count: u32,
-    context: StateContext,
+impl JournalEntry {
+    /// revert journal
+    pub fn revert<S>(self, state_db: &mut StateDB<S>) {
+        use JournalEntry::*;
+
+        match self {
+            UpdateRaw { key, prev_value } => {
+                state_db.dirty_state.insert(key, prev_value);
+            }
+            SetAccountCount { prev_count } => {
+                state_db.dirty_account_count = Some(prev_count);
+            }
+            InsertScript {
+                script_hash,
+                prev_exist,
+            } => {
+                if !prev_exist {
+                    state_db.dirty_scripts.remove(&script_hash);
+                }
+            }
+            InsertData {
+                data_hash,
+                prev_exist,
+            } => {
+                if !prev_exist {
+                    state_db.dirty_data.remove(&data_hash);
+                }
+            }
+        }
+    }
+}
+
+#[derive(Debug, Default, Clone)]
+pub struct Journal {
+    entries: im::Vector<JournalEntry>,
+}
+
+impl Journal {
+    pub fn len(&self) -> usize {
+        self.entries.len()
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.entries.is_empty()
+    }
+
+    /// Revert journal to len
+    /// Return reverted entries sorted in journal emit order
+    pub fn revert_entries(&mut self, len: usize) -> im::Vector<JournalEntry> {
+        self.entries.slice(len..)
+    }
+
+    pub fn push(&mut self, entry: JournalEntry) {
+        self.entries.push_back(entry);
+    }
+
+    pub fn clear(&mut self) {
+        self.entries.clear();
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct Revision {
+    id: usize,
+    journal_len: usize,
+}
+
+#[derive(Debug, Default)]
+pub struct StateTracker {
+    touched_keys: Mutex<HashSet<H256>>,
+}
+
+impl StateTracker {
+    /// Return touched keys
+    pub fn touched_keys(&self) -> &Mutex<HashSet<H256>> {
+        &self.touched_keys
+    }
+
+    /// Record a key in the tracker
+    pub fn touch_key(&self, key: &H256) {
+        self.touched_keys.lock().unwrap().insert(*key);
+    }
+
+    /// Record a key in the tracker
+    pub fn clear(&mut self) {
+        self.touched_keys.lock().unwrap().clear();
+    }
+}
+
+pub struct StateDB<S> {
+    /// inner state
+    state: S,
+    /// journals
+    journal: Journal,
+    /// next_revision_id
+    next_revision_id: usize,
+    /// revisions
+    revisions: im::Vector<Revision>,
+    /// dirty state in memory
+    dirty_state: im::HashMap<H256, H256>,
+    /// dirty account count
+    dirty_account_count: Option<u32>,
+    /// dirty scripts
+    dirty_scripts: im::HashMap<H256, packed::Script>,
+    /// dirty data
+    dirty_data: im::HashMap<H256, Bytes>,
+    /// state tracker
+    state_tracker: Option<StateTracker>,
+    /// last state root
+    last_state_root: H256,
+}
+
+impl<S: Clone> Clone for StateDB<S> {
+    fn clone(&self) -> Self {
+        Self {
+            state: self.state.clone(),
+            journal: self.journal.clone(),
+            next_revision_id: self.next_revision_id,
+            revisions: self.revisions.clone(),
+            dirty_state: self.dirty_state.clone(),
+            dirty_account_count: self.dirty_account_count,
+            dirty_scripts: self.dirty_scripts.clone(),
+            dirty_data: self.dirty_data.clone(),
+            state_tracker: None,
+            last_state_root: self.last_state_root,
+        }
+    }
+}
+
+impl MemStateDB {
+    /// From store
+    pub fn from_store(store: StoreSnapshot) -> Result<Self> {
+        // build from last valid block
+        let block = store.get_last_valid_tip_block()?;
+        let tip_state = block.raw().post_account();
+        let smt = SMT::new(
+            tip_state.merkle_root().unpack(),
+            SMTStateStore::new(MemStore::new(store)),
+        );
+        let inner = MemStateTree::new(smt, tip_state.count().unpack());
+        Ok(Self::new(inner))
+    }
+
+    pub fn inner_smt_tree(&self) -> &SMT<SMTStateStore<MemStore>> {
+        self.state.smt()
+    }
+}
+
+impl<Store: ChainStore + HistoryStateStore + CodeStore + KVStore> BlockStateDB<Store> {
+    /// From store
+    pub fn from_store(store: Store, rw_config: RWConfig) -> Result<Self> {
+        // build from last valid block
+        let block = store.get_last_valid_tip_block()?;
+        let tip_state = block.raw().post_account();
+        let smt = SMT::new(tip_state.merkle_root().unpack(), SMTStateStore::new(store));
+        let inner = HistoryState::new(smt, tip_state.count().unpack(), rw_config);
+        Ok(Self::new(inner))
+    }
+
+    /// Detach block state
+    /// The caller must avoid has dirty state, otherwise, the state may inconsisted after the detaching
+    pub fn detach_block_state(&mut self, block_number: u64) -> Result<()> {
+        self.state.detach_block_state(block_number)
+    }
 }
 
-impl<'a> StateTree<'a> {
-    pub fn new(
-        tree: SMT<SMTStore<'a, StoreTransaction>>,
-        account_count: u32,
-        context: StateContext,
-    ) -> Self {
-        StateTree {
-            tree,
-            account_count,
-            context,
+impl<S: State + CodeStore> StateDB<S> {
+    pub fn new(mut state: S) -> Self {
+        let last_state_root = state.finalise_root().expect("can't get state root");
+        Self {
+            state,
+            journal: Journal::default(),
+            next_revision_id: 0,
+            revisions: Default::default(),
+            dirty_state: Default::default(),
+            dirty_account_count: Default::default(),
+            dirty_data: Default::default(),
+            dirty_scripts: Default::default(),
+            state_tracker: None,
+            last_state_root,
         }
     }
 
     // Perform basic state checking
     pub fn check_state(&self) -> Result<()> {
-        let non_exit_account = self.get_script_hash(self.account_count)?;
+        let non_exit_account = self.get_script_hash(self.get_account_count()?)?;
         assert_eq!(
             non_exit_account,
             H256::zero(),
             "Detect inconsistent state: account {} should be non-exist",
-            self.account_count
+            self.get_account_count()?
         );
 
         // check first 100 account
-        for i in 0..std::cmp::min(100, self.account_count) {
+        for i in 0..std::cmp::min(100, self.get_account_count()?) {
             let script_hash = self.get_script_hash(i)?;
             assert_ne!(
                 script_hash,
@@ -66,14 +246,14 @@ impl<'a> StateTree<'a> {
                 self.get_script(&script_hash).is_some(),
                 "Detect inconsistent state: script {} not exist",
                 {
-                    let hash: Byte32 = script_hash.pack();
+                    let hash: packed::Byte32 = script_hash.pack();
                     hash
                 }
             );
         }
 
         // check last 100 account
-        for i in self.account_count.saturating_sub(100)..self.account_count {
+        for i in self.get_account_count()?.saturating_sub(100)..self.get_account_count()? {
             let script_hash = self.get_script_hash(i)?;
             assert_ne!(
                 script_hash,
@@ -85,7 +265,7 @@ impl<'a> StateTree<'a> {
                 self.get_script(&script_hash).is_some(),
                 "Detect inconsistent state: script {} not exist",
                 {
-                    let hash: Byte32 = script_hash.pack();
+                    let hash: packed::Byte32 = script_hash.pack();
                     hash
                 }
             );
@@ -94,152 +274,306 @@ impl<'a> StateTree<'a> {
         Ok(())
     }
 
-    pub fn get_merkle_state(&self) -> AccountMerkleState {
-        AccountMerkleState::new_builder()
-            .merkle_root(self.tree.root().pack())
-            .count(self.account_count.pack())
-            .build()
-    }
-
-    /// Detach block state from state tree
-    pub fn detach_block_state(&mut self) -> Result<()> {
-        let block_number = match self.context {
-            StateContext::DetachBlock(block_number) => block_number,
-            ctx => return Err(anyhow!("Wrong context in detach block state: {:?}", ctx)),
-        };
-
-        // reset states to previous value
-        let parent_block_number = block_number.saturating_sub(1);
-        let reverted_key_values: Vec<_> = self
-            .db()
-            .iter_block_state_record(block_number)
-            .map(|record_key| {
-                let state_key = record_key.state_key();
-                let last_value = self
-                    .db()
-                    .get_history_state(parent_block_number, &state_key)
-                    .unwrap_or_else(H256::zero);
-                (state_key, last_value)
-            })
-            .collect();
-        for (state_key, last_value) in reverted_key_values {
-            self.update_raw(state_key, last_value)?;
-        }
-
-        // remove block's state record
-        self.db().remove_block_state_record(block_number)?;
+    /// Return last state root
+    /// Invoke `calculate_root` will update this value
+    pub fn last_state_root(&self) -> H256 {
+        self.last_state_root
+    }
+
+    /// create snapshot
+    pub fn snapshot(&mut self) -> usize {
+        let id = self.next_revision_id;
+        self.next_revision_id += 1;
+        self.revisions.push_back(Revision {
+            id,
+            journal_len: self.journal.len(),
+        });
+        id
+    }
+
+    /// revert to a snapshot
+    pub fn revert(&mut self, id: usize) -> Result<()> {
+        // find revision
+        let rev_index = self
+            .revisions
+            .binary_search_by_key(&id, |r| r.id)
+            .map_err(|_id| anyhow!("Invalid revision id"))?;
+        let rev = &self.revisions[rev_index];
+
+        // replay to revert journal
+        let revert_entries = self.journal.revert_entries(rev.journal_len);
+        for entry in revert_entries.into_iter().rev() {
+            entry.revert(self);
+        }
 
+        // remove expired revisions
+        self.revisions.truncate(rev_index);
         Ok(())
     }
 
-    fn db(&self) -> &StoreTransaction {
-        self.tree.store().inner_store()
+    /// write dirty state to DB
+    pub fn finalise(&mut self) -> Result<()> {
+        // write account count
+        if let Some(count) = self.dirty_account_count {
+            self.state.set_account_count(count)?;
+        }
+        // write state
+        for (k, v) in &self.dirty_state {
+            self.state.update_raw(*k, *v)?;
+        }
+        // write scripts
+        for (script_hash, script) in &self.dirty_scripts {
+            self.state.insert_script(*script_hash, script.to_owned());
+        }
+        // write data
+        for (data_hash, data) in &self.dirty_data {
+            self.state.insert_data(*data_hash, data.to_owned());
+        }
+        // clear
+        self.clear_journal_and_dirty()
+    }
+
+    #[cfg(test)]
+    pub(crate) fn is_dirty(&self) -> bool {
+        self.journal.len() != 0
+            || !self.revisions.is_empty()
+            || self.dirty_account_count.is_some()
+            || !self.dirty_state.is_empty()
+            || !self.dirty_scripts.is_empty()
+            || !self.dirty_data.is_empty()
+    }
+
+    /// clear journal and dirty
+    fn clear_journal_and_dirty(&mut self) -> Result<()> {
+        // clear journal
+        self.journal.clear();
+        // clear revisions
+        self.revisions.clear();
+        // clear dirties
+        self.dirty_account_count = None;
+        self.dirty_state.clear();
+        self.dirty_scripts.clear();
+        self.dirty_data.clear();
+        Ok(())
+    }
+
+    pub fn set_state_tracker(&mut self, tracker: StateTracker) {
+        self.state_tracker = Some(tracker);
+    }
+
+    pub fn state_tracker(&self) -> Option<&StateTracker> {
+        self.state_tracker.as_ref()
+    }
+
+    pub fn take_state_tracker(&mut self) -> Option<StateTracker> {
+        self.state_tracker.take()
     }
 }
 
-impl<'a> State for StateTree<'a> {
+impl<S: State + CodeStore> State for StateDB<S> {
     fn get_raw(&self, key: &H256) -> Result<H256, StateError> {
-        let v = match self.context {
-            StateContext::ReadOnlyHistory(block_number) => self
-                .db()
-                .get_history_state(block_number, key)
-                .unwrap_or_default(),
-            _ => self.tree.get(key)?,
-        };
-        if log_enabled!(log::Level::Trace) {
-            let k: Byte32 = key.pack();
-            let v: Byte32 = v.pack();
-            log::trace!(
-                "[state-trace] get_raw ctx:{:?} k:{} v:{}",
-                self.context,
-                k,
-                v
-            );
+        if let Some(tracker) = self.state_tracker.as_ref() {
+            tracker.touch_key(key);
         }
-        Ok(v)
+        if let Some(v) = self.dirty_state.get(key) {
+            return Ok(*v);
+        }
+        self.state.get_raw(key)
     }
 
     fn update_raw(&mut self, key: H256, value: H256) -> Result<(), StateError> {
-        self.tree.update(key, value)?;
-        // record block's kv state
-        match self.context {
-            StateContext::AttachBlock(block_number) => {
-                self.db()
-                    .record_block_state(block_number, key, value)
-                    .expect("record block state");
-            }
-            StateContext::DetachBlock(_) => {
-                // ignore
-            }
-            ctx => {
-                panic!("wrong ctx: {:?}", ctx);
-            }
-        }
-        if log_enabled!(log::Level::Trace) {
-            let k: Byte32 = key.pack();
-            let v: Byte32 = value.pack();
-            log::trace!(
-                "[state-trace] update_raw ctx:{:?} k:{} v:{}",
-                self.context,
-                k,
-                v
-            );
+        if let Some(tracker) = self.state_tracker.as_ref() {
+            tracker.touch_key(&key);
         }
+        self.journal.push(JournalEntry::UpdateRaw {
+            key,
+            prev_value: self.get_raw(&key)?,
+        });
+        self.dirty_state.insert(key, value);
         Ok(())
     }
 
     fn get_account_count(&self) -> Result<u32, StateError> {
-        if log_enabled!(log::Level::Trace) {
-            log::trace!(
-                "[state-trace] get_account_count ctx:{:?} count:{}",
-                self.context,
-                self.account_count
-            );
+        if let Some(count) = self.dirty_account_count {
+            return Ok(count);
         }
-        Ok(self.account_count)
+        self.state.get_account_count()
     }
 
     fn set_account_count(&mut self, count: u32) -> Result<(), StateError> {
-        if log_enabled!(log::Level::Trace) {
-            log::trace!(
-                "[state-trace] set_account_count ctx:{:?} origin: {} count:{}",
-                self.context,
-                self.account_count,
-                count
-            );
-        }
-        self.account_count = count;
+        self.journal.push(JournalEntry::SetAccountCount {
+            prev_count: self.get_account_count()?,
+        });
+        self.dirty_account_count = Some(count);
         Ok(())
     }
 
-    fn calculate_root(&self) -> Result<H256, StateError> {
-        let root = self.tree.root();
-        Ok(*root)
+    /// Finalise in-memory dirty state and calculate root
+    fn finalise_root(&mut self) -> Result<H256, StateError> {
+        // finalise dirty state
+        self.finalise().map_err(|err| {
+            log::error!("finalise error: {}", err);
+            StateError::Store
+        })?;
+        self.last_state_root = self.state.finalise_root()?;
+        Ok(self.last_state_root)
     }
 }
 
-impl<'a> CodeStore for StateTree<'a> {
+impl<S: CodeStore> CodeStore for StateDB<S> {
     fn insert_script(&mut self, script_hash: H256, script: packed::Script) {
-        self.db()
-            .insert_raw(COLUMN_SCRIPT, script_hash.as_slice(), script.as_slice())
-            .expect("insert script");
+        self.journal.push(JournalEntry::InsertScript {
+            script_hash,
+            prev_exist: self.get_script(&script_hash).is_some(),
+        });
+        self.dirty_scripts.insert(script_hash, script);
     }
 
     fn get_script(&self, script_hash: &H256) -> Option<packed::Script> {
-        self.db()
-            .get(COLUMN_SCRIPT, script_hash.as_slice())
-            .map(|slice| from_box_should_be_ok!(packed::ScriptReader, slice))
+        if let Some(script) = self.dirty_scripts.get(script_hash) {
+            return Some(script.clone());
+        }
+        self.state.get_script(script_hash)
     }
 
     fn insert_data(&mut self, data_hash: H256, code: Bytes) {
-        self.db()
-            .insert_raw(COLUMN_DATA, data_hash.as_slice(), &code)
-            .expect("insert data");
+        self.journal.push(JournalEntry::InsertData {
+            data_hash,
+            prev_exist: self.get_data(&data_hash).is_some(),
+        });
+        self.dirty_data.insert(data_hash, code);
     }
 
     fn get_data(&self, data_hash: &H256) -> Option<Bytes> {
-        self.db()
-            .get(COLUMN_DATA, data_hash.as_slice())
-            .map(|slice| Bytes::from(slice.to_vec()))
+        if let Some(data) = self.dirty_data.get(data_hash) {
+            return Some(data.to_owned());
+        }
+        self.state.get_data(data_hash)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use gw_common::{h256_ext::H256Ext, smt::SMT, state::State, H256};
+    use gw_traits::CodeStore;
+
+    use crate::{
+        smt::smt_store::SMTStateStore,
+        snapshot::StoreSnapshot,
+        state::{
+            overlay::{mem_state::MemStateTree, mem_store::MemStore},
+            MemStateDB,
+        },
+        Store,
+    };
+
+    fn new_state(store: StoreSnapshot) -> MemStateDB {
+        let smt = SMT::new(H256::zero(), SMTStateStore::new(MemStore::new(store)));
+        let inner = MemStateTree::new(smt, 0);
+        MemStateDB::new(inner)
+    }
+
+    fn cmp_dirty_state(state_a: &MemStateDB, state_b: &MemStateDB) -> bool {
+        // account count
+        if state_a.get_account_count() != state_b.get_account_count() {
+            return false;
+        }
+        // scripts
+        for script_hash in state_a
+            .dirty_scripts
+            .keys()
+            .chain(state_b.dirty_scripts.keys())
+        {
+            if state_a.get_script(script_hash) != state_b.get_script(script_hash) {
+                return false;
+            }
+        }
+        // data
+        for data_hash in state_a.dirty_data.keys().chain(state_b.dirty_data.keys()) {
+            if state_a.get_data(data_hash) != state_b.get_data(data_hash) {
+                return false;
+            }
+        }
+        // kv
+        for key in state_a.dirty_state.keys().chain(state_b.dirty_state.keys()) {
+            if state_a.get_raw(key) != state_b.get_raw(key) {
+                return false;
+            }
+        }
+
+        true
+    }
+
+    #[test]
+    fn test_revert_to_histories_revision() {
+        let store = Store::open_tmp().unwrap();
+        let mut state = new_state(store.get_snapshot());
+        let mem_0 = state.clone();
+        let snap_0 = state.snapshot();
+        state
+            .update_raw(H256::from_u32(1), H256::from_u32(1))
+            .unwrap();
+        state
+            .update_raw(H256::from_u32(2), H256::from_u32(2))
+            .unwrap();
+        let mem_1 = state.clone();
+        let snap_1 = state.snapshot();
+
+        // should update the mem DB
+        state
+            .update_raw(H256::from_u32(3), H256::from_u32(3))
+            .unwrap();
+        let mem_2 = state.clone();
+        assert!(!cmp_dirty_state(&mem_1, &mem_2));
+
+        // revert to snap_1
+        state.revert(snap_1).unwrap();
+        assert!(cmp_dirty_state(&mem_1, &state));
+
+        // revert to snap_0
+        state.revert(snap_0).unwrap();
+        assert!(cmp_dirty_state(&mem_0, &state));
+    }
+
+    #[test]
+    fn test_clear_dirty_state() {
+        let store = Store::open_tmp().unwrap();
+        let mut state = new_state(store.get_snapshot());
+        let mem_0 = state.clone();
+        assert!(!state.is_dirty());
+        state
+            .update_raw(H256::from_u32(1), H256::from_u32(1))
+            .unwrap();
+        state
+            .update_raw(H256::from_u32(2), H256::from_u32(2))
+            .unwrap();
+        assert!(state.is_dirty());
+
+        // clear journal and dirty state
+        state.clear_journal_and_dirty().unwrap();
+        assert!(!state.is_dirty());
+        // the dirty state is cleared
+        assert!(cmp_dirty_state(&mem_0, &state));
+    }
+
+    #[test]
+    fn test_finalise_dirty_state() {
+        let store = Store::open_tmp().unwrap();
+        let mut state = new_state(store.get_snapshot());
+        assert!(!state.is_dirty());
+        state
+            .update_raw(H256::from_u32(1), H256::from_u32(1))
+            .unwrap();
+        state
+            .update_raw(H256::from_u32(2), H256::from_u32(2))
+            .unwrap();
+        let mem_1 = state.clone();
+        assert!(state.is_dirty());
+
+        // finalise
+        state.finalise().unwrap();
+        assert!(!state.is_dirty());
+        // the dirty state is cleared, but the state is write into the store
+        assert!(cmp_dirty_state(&mem_1, &state));
     }
 }
diff --git a/crates/store/src/state/state_tracker.rs b/crates/store/src/state/state_tracker.rs
deleted file mode 100644
index c53714940..000000000
--- a/crates/store/src/state/state_tracker.rs
+++ /dev/null
@@ -1,39 +0,0 @@
-use std::collections::HashSet;
-use std::sync::{Arc, Mutex};
-
-use gw_common::H256;
-
-pub struct StateTracker {
-    touched_keys: Option<Arc<Mutex<HashSet<H256>>>>,
-}
-
-impl Default for StateTracker {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-impl StateTracker {
-    pub fn new() -> Self {
-        StateTracker { touched_keys: None }
-    }
-
-    /// Enable state tracking
-    pub fn enable(&mut self) {
-        if self.touched_keys.is_none() {
-            self.touched_keys = Some(Default::default())
-        }
-    }
-
-    /// Return touched keys
-    pub fn touched_keys(&self) -> Option<Arc<Mutex<HashSet<H256>>>> {
-        self.touched_keys.as_ref().cloned()
-    }
-
-    /// Record a key in the tracker
-    pub fn touch_key(&self, key: &H256) {
-        if let Some(touched_keys) = self.touched_keys.as_ref() {
-            touched_keys.lock().unwrap().insert(*key);
-        }
-    }
-}
diff --git a/crates/store/src/state/traits.rs b/crates/store/src/state/traits.rs
new file mode 100644
index 000000000..d955d15c4
--- /dev/null
+++ b/crates/store/src/state/traits.rs
@@ -0,0 +1,5 @@
+use gw_common::smt::SMT;
+
+pub trait SMTTree<S> {
+    fn smt_tree(&self) -> SMT<S>;
+}
diff --git a/crates/store/src/store_impl.rs b/crates/store/src/store_impl.rs
index dafdb14e8..e6192459c 100644
--- a/crates/store/src/store_impl.rs
+++ b/crates/store/src/store_impl.rs
@@ -1,11 +1,12 @@
 //! Storage implementation
 
+use crate::smt::smt_store::SMTBlockStore;
+use crate::state::history::history_state::RWConfig;
+use crate::state::BlockStateDB;
 use crate::traits::chain_store::ChainStore;
 use crate::traits::kv_store::KVStoreRead;
 use crate::write_batch::StoreWriteBatch;
-use crate::{
-    snapshot::StoreSnapshot, state::state_db::StateContext, transaction::StoreTransaction,
-};
+use crate::{snapshot::StoreSnapshot, transaction::StoreTransaction};
 use anyhow::Result;
 use gw_common::error::Error;
 use gw_common::smt::Blake2bHasher;
@@ -62,16 +63,18 @@ impl<'a> Store {
     }
 
     pub fn check_state(&self) -> Result<()> {
-        let db = self.begin_transaction();
-
         // check state tree
-        let tree = db.state_tree(StateContext::ReadOnly)?;
-        tree.check_state()?;
+        {
+            let db = self.begin_transaction();
+            let tree = BlockStateDB::from_store(&db, RWConfig::readonly())?;
+            tree.check_state()?;
+        }
 
         // check block smt
         {
-            let smt = db.block_smt()?;
+            let db = self.get_snapshot();
             let tip_number: u64 = db.get_last_valid_tip_block()?.raw().number().unpack();
+            let smt = SMTBlockStore::new(db).to_smt()?;
             for number in tip_number.saturating_sub(100)..tip_number {
                 let block_hash = self.get_block_hash_by_number(number)?.expect("exist");
                 let block = self.get_block(&block_hash)?.expect("exist");
@@ -82,7 +85,6 @@ impl<'a> Store {
                 assert_eq!(&root, smt.root(), "block smt root consistent");
             }
         }
-        db.rollback()?;
         Ok(())
     }
 
diff --git a/crates/store/src/tests/state_db.rs b/crates/store/src/tests/state_db.rs
index 500587643..0087f7bde 100644
--- a/crates/store/src/tests/state_db.rs
+++ b/crates/store/src/tests/state_db.rs
@@ -1,5 +1,5 @@
 use crate::{
-    state::state_db::StateContext,
+    state::{history::history_state::RWConfig, BlockStateDB},
     traits::{chain_store::ChainStore, kv_store::KVStoreWrite},
     transaction::StoreTransaction,
     Store,
@@ -13,9 +13,13 @@ use gw_types::{
     prelude::{Builder, Entity, Pack, Unpack},
 };
 
-fn build_block(state: &impl State, block_number: u64, prev_txs_state_checkpoint: H256) -> L2Block {
+fn build_block(
+    state: &mut impl State,
+    block_number: u64,
+    prev_txs_state_checkpoint: H256,
+) -> L2Block {
     let post_state = AccountMerkleState::new_builder()
-        .merkle_root(state.calculate_root().unwrap().pack())
+        .merkle_root(state.finalise_root().unwrap().pack())
         .count(state.get_account_count().unwrap().pack())
         .build();
     L2Block::new_builder()
@@ -64,7 +68,7 @@ fn test_state_with_version() {
     // block 1
     {
         let db = store.begin_transaction();
-        let mut state = db.state_tree(StateContext::AttachBlock(1)).unwrap();
+        let mut state = BlockStateDB::from_store(&db, RWConfig::attach_block(1)).unwrap();
         state
             .update_raw(H256::from_u32(1), H256::from_u32(2))
             .unwrap();
@@ -83,7 +87,7 @@ fn test_state_with_version() {
         state
             .update_raw(H256::from_u32(4), H256::from_u32(4))
             .unwrap();
-        commit_block(&db, build_block(&state, 1, prev_txs_state_checkpoint));
+        commit_block(&db, build_block(&mut state, 1, prev_txs_state_checkpoint));
         prev_txs_state_checkpoint = state.calculate_state_checkpoint().unwrap();
         db.set_block_submit_tx(1, &Transaction::default().as_reader())
             .unwrap();
@@ -97,8 +101,8 @@ fn test_state_with_version() {
         db.commit().unwrap();
     }
     {
-        let db = store.begin_transaction();
-        let state = db.state_tree(StateContext::ReadOnly).unwrap();
+        let db = &store.begin_transaction();
+        let state = BlockStateDB::from_store(db, RWConfig::readonly()).unwrap();
         let v = state.get_raw(&H256::from_u32(1)).unwrap();
         assert_eq!(v, H256::from_u32(1));
         let v = state.get_raw(&H256::from_u32(2)).unwrap();
@@ -115,8 +119,8 @@ fn test_state_with_version() {
 
     // attach block 2
     {
-        let db = store.begin_transaction();
-        let mut state = db.state_tree(StateContext::AttachBlock(2)).unwrap();
+        let db = &store.begin_transaction();
+        let mut state = BlockStateDB::from_store(db, RWConfig::attach_block(2)).unwrap();
         state
             .update_raw(H256::from_u32(1), H256::from_u32(1))
             .unwrap();
@@ -127,7 +131,7 @@ fn test_state_with_version() {
         state
             .update_raw(H256::from_u32(5), H256::from_u32(25))
             .unwrap();
-        commit_block(&db, build_block(&state, 2, prev_txs_state_checkpoint));
+        commit_block(&db, build_block(&mut state, 2, prev_txs_state_checkpoint));
         db.set_last_confirmed_block_number_hash(
             &NumberHash::new_builder()
                 .number(2.pack())
@@ -144,7 +148,7 @@ fn test_state_with_version() {
     }
     {
         let db = store.begin_transaction();
-        let state = db.state_tree(StateContext::ReadOnly).unwrap();
+        let state = BlockStateDB::from_store(&db, RWConfig::readonly()).unwrap();
         let v = state.get_raw(&H256::from_u32(1)).unwrap();
         assert_eq!(v, H256::from_u32(1));
         let v = state.get_raw(&H256::from_u32(2)).unwrap();
@@ -159,16 +163,16 @@ fn test_state_with_version() {
 
     // detach block 2
     {
-        let db = store.begin_transaction();
+        let db = &store.begin_transaction();
         db.detach_block(&db.get_tip_block().unwrap()).unwrap();
-        let mut state = db.state_tree(StateContext::DetachBlock(2)).unwrap();
-        state.detach_block_state().unwrap();
+        let mut state = BlockStateDB::from_store(db, RWConfig::detach_block()).unwrap();
+        state.detach_block_state(2).unwrap();
         prev_txs_state_checkpoint = state.calculate_state_checkpoint().unwrap();
         db.commit().unwrap();
     }
     {
-        let db = store.begin_transaction();
-        let state = db.state_tree(StateContext::ReadOnly).unwrap();
+        let db = &store.begin_transaction();
+        let state = BlockStateDB::from_store(db, RWConfig::readonly()).unwrap();
         let v = state.get_raw(&H256::from_u32(1)).unwrap();
         assert_eq!(v, H256::from_u32(1));
         let v = state.get_raw(&H256::from_u32(2)).unwrap();
@@ -189,7 +193,7 @@ fn test_state_with_version() {
     // attach 2 again
     {
         let db = store.begin_transaction();
-        let mut state = db.state_tree(StateContext::AttachBlock(2)).unwrap();
+        let mut state = BlockStateDB::from_store(&db, RWConfig::attach_block(2)).unwrap();
         state
             .update_raw(H256::from_u32(1), H256::from_u32(1))
             .unwrap();
@@ -200,12 +204,12 @@ fn test_state_with_version() {
         state
             .update_raw(H256::from_u32(5), H256::from_u32(25))
             .unwrap();
-        commit_block(&db, build_block(&state, 2, prev_txs_state_checkpoint));
+        commit_block(&db, build_block(&mut state, 2, prev_txs_state_checkpoint));
         db.commit().unwrap();
     }
     {
         let db = store.begin_transaction();
-        let state = db.state_tree(StateContext::ReadOnly).unwrap();
+        let state = BlockStateDB::from_store(&db, RWConfig::readonly()).unwrap();
         let v = state.get_raw(&H256::from_u32(1)).unwrap();
         assert_eq!(v, H256::from_u32(1));
         let v = state.get_raw(&H256::from_u32(2)).unwrap();
@@ -221,7 +225,7 @@ fn test_state_with_version() {
     // check block 1
     {
         let db = store.begin_transaction();
-        let state = db.state_tree(StateContext::ReadOnlyHistory(1)).unwrap();
+        let state = BlockStateDB::from_store(&db, RWConfig::history_block(1)).unwrap();
         let v = state.get_raw(&H256::from_u32(1)).unwrap();
         assert_eq!(v, H256::from_u32(1));
         let v = state.get_raw(&H256::from_u32(2)).unwrap();
diff --git a/crates/store/src/tests/transaction.rs b/crates/store/src/tests/transaction.rs
index c7e0421c1..075796756 100644
--- a/crates/store/src/tests/transaction.rs
+++ b/crates/store/src/tests/transaction.rs
@@ -8,7 +8,7 @@ use std::collections::HashMap;
 #[test]
 fn insert_and_get() {
     let store = Store::open_tmp().unwrap();
-    let store_txn = store.begin_transaction();
+    let store_txn = &store.begin_transaction();
 
     store_txn.insert_raw(0, &[0, 0], &[0, 0, 0]).unwrap();
     store_txn.insert_raw(1, &[1, 1], &[1, 1, 1]).unwrap();
@@ -16,7 +16,7 @@ fn insert_and_get() {
     store_txn.commit().unwrap();
 
     // new transaction can't be affected by uncommit transaction
-    let store_txn = store.begin_transaction();
+    let store_txn = &store.begin_transaction();
 
     assert_eq!(
         vec![0u8, 0, 0].into_boxed_slice(),
@@ -46,18 +46,18 @@ fn insert_and_get() {
 #[test]
 fn delete() {
     let store = Store::open_tmp().unwrap();
-    let store_txn = store.begin_transaction();
+    let store_txn = &store.begin_transaction();
 
     store_txn.insert_raw(1, &[2], &[1, 1, 1]).unwrap();
     store_txn.delete(1, &[2]).unwrap();
     store_txn.commit().unwrap();
 
     // new transaction is not affected by uncommit transaction
-    let store_txn = store.begin_transaction();
+    let store_txn = &store.begin_transaction();
     assert!(store_txn.get(1, &[2]).is_none());
 
     // delete a nonexistent
-    let store_txn = store.begin_transaction();
+    let store_txn = &store.begin_transaction();
     assert!(store_txn.delete(1, &[3]).is_ok());
     assert!(store_txn.commit().is_ok());
 }
@@ -65,14 +65,14 @@ fn delete() {
 #[test]
 fn insert_without_commit() {
     let store = Store::open_tmp().unwrap();
-    let store_txn = store.begin_transaction();
+    let store_txn = &store.begin_transaction();
 
     // insert without commit
     store_txn.insert_raw(0, &[0, 0], &[0, 0, 0]).unwrap();
     store_txn.insert_raw(1, &[1, 1], &[1, 1, 1]).unwrap();
 
     // new transaction can't be affected by uncommit transaction
-    let store_txn = store.begin_transaction();
+    let store_txn = &store.begin_transaction();
 
     assert!(store_txn.get(0, &[0, 0]).is_none());
     assert!(store_txn.get(1, &[1, 1]).is_none());
@@ -81,10 +81,10 @@ fn insert_without_commit() {
 #[test]
 fn intersect_transactions() {
     let store = Store::open_tmp().unwrap();
-    let store_txn_1 = store.begin_transaction();
-    let store_txn_2 = store.begin_transaction();
-    let store_txn_3 = store.begin_transaction();
-    let store_txn_4 = store.begin_transaction();
+    let store_txn_1 = &store.begin_transaction();
+    let store_txn_2 = &store.begin_transaction();
+    let store_txn_3 = &store.begin_transaction();
+    let store_txn_4 = &store.begin_transaction();
 
     // store_txn_2 insert key without commit
     store_txn_2.insert_raw(1, &[1, 1], &[1, 1, 1]).unwrap();
@@ -149,7 +149,7 @@ fn intersect_transactions() {
 #[test]
 fn seek_for_prev() {
     let store = Store::open_tmp().unwrap();
-    let store_txn = store.begin_transaction();
+    let store_txn = &store.begin_transaction();
 
     store_txn.insert_raw(1, &[0], &[0, 0, 0]).unwrap();
     store_txn.insert_raw(1, &[1], &[1, 1, 1]).unwrap();
@@ -157,7 +157,7 @@ fn seek_for_prev() {
     store_txn.insert_raw(1, &[3], &[3, 3, 3]).unwrap();
     store_txn.commit().unwrap();
 
-    let store_txn = store.begin_transaction();
+    let store_txn = &store.begin_transaction();
     assert_eq!(
         vec![0u8, 0, 0].into_boxed_slice(),
         store_txn.get(1, &[0]).unwrap()
@@ -208,7 +208,7 @@ fn seek_for_prev() {
 #[test]
 fn seek_for_prev_with_suffix() {
     let store = Store::open_tmp().unwrap();
-    let store_txn = store.begin_transaction();
+    let store_txn = &store.begin_transaction();
 
     let (block_num_1, tx_idx_5) = (1u64, 5u32);
     let (block_num_2, tx_idx_7) = (2u64, 7u32);
@@ -318,7 +318,7 @@ fn seek_for_prev_with_suffix() {
 fn delete_range() {
     let store = Store::open_tmp().unwrap();
 
-    let store_txn = store.begin_transaction();
+    let store_txn = &store.begin_transaction();
     store_txn.insert_raw(1, &[0], &[0, 0]).unwrap();
     store_txn.insert_raw(1, &[1], &[1, 1]).unwrap();
     store_txn.insert_raw(1, &[2], &[2, 2]).unwrap();
@@ -339,7 +339,7 @@ fn delete_range() {
 fn range_search_and_delete() {
     let store = Store::open_tmp().unwrap();
 
-    let store_txn = store.begin_transaction();
+    let store_txn = &store.begin_transaction();
     store_txn.insert_raw(1, &[0, 0], &[1, 0, 0]).unwrap();
     store_txn.insert_raw(1, &[0, 1], &[1, 0, 1]).unwrap();
     store_txn.insert_raw(1, &[0, 2], &[3, 0, 2]).unwrap();
diff --git a/crates/store/src/transaction/code_store_impl.rs b/crates/store/src/transaction/code_store_impl.rs
new file mode 100644
index 000000000..37ba73602
--- /dev/null
+++ b/crates/store/src/transaction/code_store_impl.rs
@@ -0,0 +1,30 @@
+use gw_common::H256;
+use gw_db::schema::{COLUMN_DATA, COLUMN_SCRIPT};
+use gw_traits::CodeStore;
+use gw_types::{bytes::Bytes, from_box_should_be_ok, packed, prelude::*};
+
+use crate::traits::kv_store::{KVStoreRead, KVStoreWrite};
+
+use super::StoreTransaction;
+
+impl CodeStore for &StoreTransaction {
+    fn insert_script(&mut self, script_hash: H256, script: packed::Script) {
+        self.insert_raw(COLUMN_SCRIPT, script_hash.as_slice(), script.as_slice())
+            .expect("insert script");
+    }
+
+    fn get_script(&self, script_hash: &H256) -> Option<packed::Script> {
+        self.get(COLUMN_SCRIPT, script_hash.as_slice())
+            .map(|slice| from_box_should_be_ok!(packed::ScriptReader, slice))
+    }
+
+    fn insert_data(&mut self, data_hash: H256, code: Bytes) {
+        self.insert_raw(COLUMN_DATA, data_hash.as_slice(), &code)
+            .expect("insert data");
+    }
+
+    fn get_data(&self, data_hash: &H256) -> Option<Bytes> {
+        self.get(COLUMN_DATA, data_hash.as_slice())
+            .map(|slice| Bytes::from(slice.to_vec()))
+    }
+}
diff --git a/crates/store/src/transaction/history_store_impl.rs b/crates/store/src/transaction/history_store_impl.rs
new file mode 100644
index 000000000..2762c528c
--- /dev/null
+++ b/crates/store/src/transaction/history_store_impl.rs
@@ -0,0 +1,98 @@
+use anyhow::Error;
+use gw_common::H256;
+use gw_db::{
+    schema::{COLUMN_BLOCK_STATE_RECORD, COLUMN_BLOCK_STATE_REVERSE_RECORD},
+    DBRawIterator, Direction, IteratorMode,
+};
+
+use crate::{
+    state::history::{
+        block_state_record::{BlockStateRecordKey, BlockStateRecordKeyReverse},
+        history_state::HistoryStateStore,
+    },
+    traits::kv_store::{KVStoreRead, KVStoreWrite},
+};
+
+use super::StoreTransaction;
+
+impl HistoryStateStore for &StoreTransaction {
+    type BlockStateRecordKeyIter = Vec<BlockStateRecordKey>;
+
+    fn iter_block_state_record(&self, block_number: u64) -> Self::BlockStateRecordKeyIter {
+        let start_key = BlockStateRecordKey::new(block_number, &H256::zero());
+        self.get_iter(
+            COLUMN_BLOCK_STATE_RECORD,
+            IteratorMode::From(start_key.as_slice(), Direction::Forward),
+        )
+        .map(|(key, _value)| BlockStateRecordKey::from_slice(&key))
+        .take_while(move |key| key.block_number() == block_number)
+        .collect()
+    }
+
+    fn remove_block_state_record(&self, block_number: u64) -> Result<(), Error> {
+        let iter = self.iter_block_state_record(block_number);
+        for record_key in iter {
+            // delete record key
+            self.delete(COLUMN_BLOCK_STATE_RECORD, record_key.as_slice())?;
+            // delete reverse record key
+            let reverse_key =
+                BlockStateRecordKeyReverse::new(record_key.block_number(), &record_key.state_key());
+            self.delete(COLUMN_BLOCK_STATE_REVERSE_RECORD, reverse_key.as_slice())?;
+        }
+        Ok(())
+    }
+
+    fn get_history_state(&self, block_number: u64, state_key: &H256) -> Option<H256> {
+        let key = BlockStateRecordKeyReverse::new(block_number, state_key);
+        let mut raw_iter: DBRawIterator = self
+            .get_iter(COLUMN_BLOCK_STATE_REVERSE_RECORD, IteratorMode::Start)
+            .into();
+        raw_iter.seek_for_prev(key.as_slice());
+
+        if !raw_iter.valid() {
+            return None;
+        }
+        match raw_iter.key() {
+            Some(prev_key) => {
+                // not a some key
+                if &prev_key[..32] != key.state_key().as_slice() {
+                    return None;
+                }
+
+                // get old value
+                let prev_reverse_key = BlockStateRecordKeyReverse::from_slice(prev_key);
+                let prev_key = BlockStateRecordKey::new(
+                    prev_reverse_key.block_number(),
+                    &prev_reverse_key.state_key(),
+                );
+
+                self.get(COLUMN_BLOCK_STATE_RECORD, prev_key.as_slice())
+                    .map(|raw| {
+                        let mut buf = [0u8; 32];
+                        buf.copy_from_slice(&raw);
+                        buf.into()
+                    })
+            }
+            _ => None,
+        }
+    }
+
+    fn record_block_state(
+        &self,
+        block_number: u64,
+        state_key: H256,
+        value: H256,
+    ) -> Result<(), Error> {
+        // insert block state key value
+        let key = BlockStateRecordKey::new(block_number, &state_key);
+        self.insert_raw(COLUMN_BLOCK_STATE_RECORD, key.as_slice(), value.as_slice())?;
+        // insert block state reverse key
+        let reverse_key = BlockStateRecordKeyReverse::new(block_number, &state_key);
+        self.insert_raw(
+            COLUMN_BLOCK_STATE_REVERSE_RECORD,
+            reverse_key.as_slice(),
+            &[],
+        )?;
+        Ok(())
+    }
+}
diff --git a/crates/store/src/transaction/mod.rs b/crates/store/src/transaction/mod.rs
index b96273d7f..54dab1d2d 100644
--- a/crates/store/src/transaction/mod.rs
+++ b/crates/store/src/transaction/mod.rs
@@ -1,3 +1,5 @@
+mod code_store_impl;
+mod history_store_impl;
 mod store_transaction;
 
 pub use store_transaction::StoreTransaction;
diff --git a/crates/store/src/transaction/store_transaction.rs b/crates/store/src/transaction/store_transaction.rs
index 3286f060f..5c753dd30 100644
--- a/crates/store/src/transaction/store_transaction.rs
+++ b/crates/store/src/transaction/store_transaction.rs
@@ -1,19 +1,17 @@
 #![allow(clippy::mutable_key_type)]
 
-use crate::state::state_db::{StateContext, StateTree};
+use crate::smt::smt_store::{SMTBlockStore, SMTRevertedBlockStore, SMTStateStore};
 use crate::traits::chain_store::ChainStore;
+use crate::traits::kv_store::KVStoreRead;
 use crate::traits::kv_store::{KVStore, KVStoreWrite};
-use crate::{smt::smt_store::SMTStore, traits::kv_store::KVStoreRead};
 use gw_common::h256_ext::H256Ext;
 use gw_common::{merkle_utils::calculate_state_checkpoint, smt::SMT, H256};
 use gw_db::schema::{
-    Col, COLUMN_ACCOUNT_SMT_BRANCH, COLUMN_ACCOUNT_SMT_LEAF, COLUMN_ASSET_SCRIPT, COLUMN_BAD_BLOCK,
-    COLUMN_BAD_BLOCK_CHALLENGE_TARGET, COLUMN_BLOCK, COLUMN_BLOCK_DEPOSIT_INFO_VEC,
-    COLUMN_BLOCK_GLOBAL_STATE, COLUMN_BLOCK_POST_FINALIZED_CUSTODIAN_CAPACITY,
-    COLUMN_BLOCK_SMT_BRANCH, COLUMN_BLOCK_SMT_LEAF, COLUMN_BLOCK_STATE_RECORD,
-    COLUMN_BLOCK_STATE_REVERSE_RECORD, COLUMN_BLOCK_SUBMIT_TX, COLUMN_BLOCK_SUBMIT_TX_HASH,
-    COLUMN_INDEX, COLUMN_MEM_POOL_TRANSACTION, COLUMN_MEM_POOL_TRANSACTION_RECEIPT,
-    COLUMN_MEM_POOL_WITHDRAWAL, COLUMN_META, COLUMN_REVERTED_BLOCK_SMT_BRANCH,
+    Col, COLUMN_ASSET_SCRIPT, COLUMN_BAD_BLOCK, COLUMN_BAD_BLOCK_CHALLENGE_TARGET, COLUMN_BLOCK,
+    COLUMN_BLOCK_DEPOSIT_INFO_VEC, COLUMN_BLOCK_GLOBAL_STATE,
+    COLUMN_BLOCK_POST_FINALIZED_CUSTODIAN_CAPACITY, COLUMN_BLOCK_SUBMIT_TX,
+    COLUMN_BLOCK_SUBMIT_TX_HASH, COLUMN_INDEX, COLUMN_MEM_POOL_TRANSACTION,
+    COLUMN_MEM_POOL_TRANSACTION_RECEIPT, COLUMN_MEM_POOL_WITHDRAWAL, COLUMN_META,
     COLUMN_REVERTED_BLOCK_SMT_LEAF, COLUMN_REVERTED_BLOCK_SMT_ROOT, COLUMN_TRANSACTION,
     COLUMN_TRANSACTION_INFO, COLUMN_TRANSACTION_RECEIPT, COLUMN_WITHDRAWAL, COLUMN_WITHDRAWAL_INFO,
     META_BLOCK_SMT_ROOT_KEY, META_CHAIN_ID_KEY, META_LAST_CONFIRMED_BLOCK_NUMBER_HASH_KEY,
@@ -21,7 +19,6 @@ use gw_db::schema::{
     META_REVERTED_BLOCK_SMT_ROOT_KEY, META_TIP_BLOCK_HASH_KEY,
 };
 use gw_db::{error::Error, iter::DBIter, DBIterator, IteratorMode, RocksDBTransaction};
-use gw_db::{DBRawIterator, Direction};
 use gw_types::packed::NumberHash;
 use gw_types::{
     from_box_should_be_ok,
@@ -33,13 +30,11 @@ use gw_types::{
 };
 use std::collections::HashSet;
 
-use crate::state::block_state_record::{BlockStateRecordKey, BlockStateRecordKeyReverse};
-
 pub struct StoreTransaction {
     pub(crate) inner: RocksDBTransaction,
 }
 
-impl KVStoreRead for StoreTransaction {
+impl KVStoreRead for &StoreTransaction {
     fn get(&self, col: Col, key: &[u8]) -> Option<Box<[u8]>> {
         self.inner
             .get(col, key)
@@ -48,7 +43,7 @@ impl KVStoreRead for StoreTransaction {
     }
 }
 
-impl KVStoreWrite for StoreTransaction {
+impl KVStoreWrite for &StoreTransaction {
     fn insert_raw(&self, col: Col, key: &[u8], value: &[u8]) -> Result<(), Error> {
         self.inner.put(col, key, value)
     }
@@ -57,8 +52,8 @@ impl KVStoreWrite for StoreTransaction {
         self.inner.delete(col, key)
     }
 }
-
-impl KVStore for StoreTransaction {}
+impl KVStore for &StoreTransaction {}
+impl ChainStore for &StoreTransaction {}
 
 impl StoreTransaction {
     pub fn commit(&self) -> Result<(), Error> {
@@ -222,20 +217,16 @@ impl StoreTransaction {
         Ok(())
     }
 
-    pub fn block_smt(&self) -> Result<SMT<SMTStore<Self>>, Error> {
-        let root = self.get_block_smt_root()?;
-        let smt_store = SMTStore::new(COLUMN_BLOCK_SMT_LEAF, COLUMN_BLOCK_SMT_BRANCH, self);
-        Ok(SMT::new(root, smt_store))
+    pub fn block_smt(&self) -> Result<SMT<SMTBlockStore<&Self>>, Error> {
+        SMTBlockStore::new(self)
+            .to_smt()
+            .map_err(|err| Error::from(err.to_string()))
     }
 
-    pub fn reverted_block_smt(&self) -> Result<SMT<SMTStore<Self>>, Error> {
-        let root = self.get_reverted_block_smt_root()?;
-        let smt_store = SMTStore::new(
-            COLUMN_REVERTED_BLOCK_SMT_LEAF,
-            COLUMN_REVERTED_BLOCK_SMT_BRANCH,
-            self,
-        );
-        Ok(SMT::new(root, smt_store))
+    pub fn reverted_block_smt(&self) -> Result<SMT<SMTRevertedBlockStore<&Self>>, Error> {
+        SMTRevertedBlockStore::new(self)
+            .to_smt()
+            .map_err(|err| Error::from(err.to_string()))
     }
 
     // TODO: prune db state
@@ -388,7 +379,7 @@ impl StoreTransaction {
 
         self.insert_raw(COLUMN_BAD_BLOCK, &block_hash, block.as_slice())?;
 
-        // Add to block smt
+        // We add all block that submitted to layer-1 to block smt, even a bad block
         let mut block_smt = self.block_smt()?;
         block_smt
             .update(block.smt_key().into(), block_hash.into())
@@ -574,106 +565,22 @@ impl StoreTransaction {
         Ok(())
     }
 
-    pub fn remove_block_state_record(&self, block_number: u64) -> Result<(), Error> {
-        let iter = self.iter_block_state_record(block_number);
-        for record_key in iter {
-            // delete record key
-            self.delete(COLUMN_BLOCK_STATE_RECORD, record_key.as_slice())?;
-            // delete reverse record key
-            let reverse_key =
-                BlockStateRecordKeyReverse::new(record_key.block_number(), &record_key.state_key());
-            self.delete(COLUMN_BLOCK_STATE_REVERSE_RECORD, reverse_key.as_slice())?;
-        }
-        Ok(())
-    }
-
-    pub fn get_history_state(&self, block_number: u64, state_key: &H256) -> Option<H256> {
-        let key = BlockStateRecordKeyReverse::new(block_number, state_key);
-        let mut raw_iter: DBRawIterator = self
-            .get_iter(COLUMN_BLOCK_STATE_REVERSE_RECORD, IteratorMode::Start)
-            .into();
-        raw_iter.seek_for_prev(key.as_slice());
-
-        if !raw_iter.valid() {
-            return None;
-        }
-        match raw_iter.key() {
-            Some(prev_key) => {
-                // not a some key
-                if &prev_key[..32] != key.state_key().as_slice() {
-                    return None;
-                }
-
-                // get old value
-                let prev_reverse_key = BlockStateRecordKeyReverse::from_slice(prev_key);
-                let prev_key = BlockStateRecordKey::new(
-                    prev_reverse_key.block_number(),
-                    &prev_reverse_key.state_key(),
-                );
-
-                self.get(COLUMN_BLOCK_STATE_RECORD, prev_key.as_slice())
-                    .map(|raw| {
-                        let mut buf = [0u8; 32];
-                        buf.copy_from_slice(&raw);
-                        buf.into()
-                    })
-            }
-            _ => None,
-        }
-    }
-
-    pub fn iter_block_state_record(
-        &self,
-        block_number: u64,
-    ) -> impl Iterator<Item = BlockStateRecordKey> + '_ {
-        let start_key = BlockStateRecordKey::new(block_number, &H256::zero());
-        self.get_iter(
-            COLUMN_BLOCK_STATE_RECORD,
-            IteratorMode::From(start_key.as_slice(), Direction::Forward),
-        )
-        .map(|(key, _value)| BlockStateRecordKey::from_slice(&key))
-        .take_while(move |key| key.block_number() == block_number)
-    }
-
     // FIXME: This method may running into inconsistent state if current state is dirty.
     // We should separate the StateDB into ReadOnly & WriteOnly,
     // The ReadOnly is for fetching history state, and the write only is for writing new state.
     // This function should only be added on the ReadOnly state.
-    pub fn account_smt(&self) -> Result<SMT<SMTStore<'_, Self>>, Error> {
-        let block = self.get_last_valid_tip_block()?;
-        let merkle_state = block.raw().post_account();
-        self.account_smt_with_merkle_state(merkle_state)
-    }
-
-    pub fn account_smt_store(&self) -> Result<SMTStore<Self>, Error> {
-        let smt_store = SMTStore::new(COLUMN_ACCOUNT_SMT_LEAF, COLUMN_ACCOUNT_SMT_BRANCH, self);
-        Ok(smt_store)
+    pub fn state_smt(&self) -> Result<SMT<SMTStateStore<&Self>>, Error> {
+        SMTStateStore::new(self)
+            .to_smt()
+            .map_err(|err| Error::from(err.to_string()))
     }
 
-    pub fn account_smt_with_merkle_state(
+    pub fn state_smt_with_merkle_state(
         &self,
         merkle_state: AccountMerkleState,
-    ) -> Result<SMT<SMTStore<Self>>, Error> {
-        let smt_store = self.account_smt_store()?;
-        Ok(SMT::new(merkle_state.merkle_root().unpack(), smt_store))
-    }
-
-    // get state tree
-    pub fn state_tree(&self, context: StateContext) -> Result<StateTree, Error> {
-        let block = match context {
-            StateContext::ReadOnlyHistory(block_number) => {
-                let block_hash = self
-                    .get_block_hash_by_number(block_number)?
-                    .ok_or_else(|| Error::from("can't find block".to_string()))?;
-                self.get_block(&block_hash)?
-                    .ok_or_else(|| "can't find block".to_string())?
-            }
-            _ => self.get_last_valid_tip_block()?,
-        };
-        let merkle_state = block.raw().post_account();
-        let account_count = merkle_state.count().unpack();
-        let tree = self.account_smt_with_merkle_state(merkle_state)?;
-        Ok(StateTree::new(tree, account_count, context))
+    ) -> Result<SMT<SMTStateStore<&Self>>, Error> {
+        let store = SMTStateStore::new(self);
+        Ok(SMT::new(merkle_state.merkle_root().unpack(), store))
     }
 
     pub fn insert_mem_pool_transaction(
@@ -723,24 +630,6 @@ impl StoreTransaction {
         Ok(())
     }
 
-    pub fn record_block_state(
-        &self,
-        block_number: u64,
-        state_key: H256,
-        value: H256,
-    ) -> Result<(), Error> {
-        // insert block state key value
-        let key = BlockStateRecordKey::new(block_number, &state_key);
-        self.insert_raw(COLUMN_BLOCK_STATE_RECORD, key.as_slice(), value.as_slice())?;
-        // insert block state reverse key
-        let reverse_key = BlockStateRecordKeyReverse::new(block_number, &state_key);
-        self.insert_raw(
-            COLUMN_BLOCK_STATE_REVERSE_RECORD,
-            reverse_key.as_slice(),
-            &[],
-        )
-    }
-
     pub fn get_mem_pool_withdrawal_iter(
         &self,
     ) -> impl Iterator<Item = (H256, packed::WithdrawalRequestExtra)> + '_ {
@@ -765,5 +654,3 @@ impl StoreTransaction {
             })
     }
 }
-
-impl ChainStore for StoreTransaction {}
diff --git a/crates/tests/src/testing_tool/chain.rs b/crates/tests/src/testing_tool/chain.rs
index b7b959f53..0dc09c2d5 100644
--- a/crates/tests/src/testing_tool/chain.rs
+++ b/crates/tests/src/testing_tool/chain.rs
@@ -613,7 +613,7 @@ pub async fn construct_block_with_timestamp(
         )
     }
     let stake_cell_owner_lock_hash = H256::zero();
-    let db = chain.store().begin_transaction();
+    let db = &chain.store().begin_transaction();
     let generator = chain.generator();
     let rollup_config_hash = (*chain.rollup_config_hash()).into();
 
diff --git a/crates/tests/src/tests/chain.rs b/crates/tests/src/tests/chain.rs
index 26f1c97ec..4ad2d4344 100644
--- a/crates/tests/src/tests/chain.rs
+++ b/crates/tests/src/tests/chain.rs
@@ -12,7 +12,10 @@ use gw_chain::chain::{
     SyncEvent, SyncParam,
 };
 use gw_common::{builtins::CKB_SUDT_ACCOUNT_ID, ckb_decimal::CKBCapacity, state::State, H256};
-use gw_store::{state::state_db::StateContext, traits::chain_store::ChainStore};
+use gw_store::{
+    state::{history::history_state::RWConfig, BlockStateDB},
+    traits::chain_store::ChainStore,
+};
 use gw_types::{
     bytes::Bytes,
     core::{ScriptHashType, Status},
@@ -132,7 +135,7 @@ async fn test_produce_blocks() {
     // check state
     {
         let db = chain.store().begin_transaction();
-        let tree = db.state_tree(StateContext::ReadOnly).unwrap();
+        let tree = BlockStateDB::from_store(&db, RWConfig::readonly()).unwrap();
         let script_hash_a: H256 = user_script_a.hash().into();
         let script_hash_b: H256 = user_script_b.hash().into();
         let id_a = tree
@@ -302,7 +305,7 @@ async fn test_layer1_fork() {
     assert_eq!(tip_block_number, 2);
 
     // revert blocks
-    let db = chain.store().begin_transaction();
+    let db = &chain.store().begin_transaction();
     let tip_block_parent_hash: H256 = tip_block.raw().parent_block_hash().unpack();
     let revert_action2 = {
         let prev_global_state = db
@@ -346,8 +349,8 @@ async fn test_layer1_fork() {
     // check account SMT, should be able to calculate account state root
     {
         let db = chain.store().begin_transaction();
-        let tree = db.state_tree(StateContext::ReadOnly).unwrap();
-        let current_account_root = tree.calculate_root().unwrap();
+        let mut tree = BlockStateDB::from_store(&db, RWConfig::readonly()).unwrap();
+        let current_account_root = tree.finalise_root().unwrap();
         let expected_account_root: H256 = tip_block.raw().post_account().merkle_root().unpack();
         assert_eq!(
             current_account_root, expected_account_root,
@@ -498,8 +501,8 @@ async fn test_layer1_revert() {
     // check account SMT, should be able to calculate account state root
     {
         let db = chain.store().begin_transaction();
-        let tree = db.state_tree(StateContext::ReadOnly).unwrap();
-        let current_account_root = tree.calculate_root().unwrap();
+        let mut tree = BlockStateDB::from_store(&db, RWConfig::readonly()).unwrap();
+        let current_account_root = tree.finalise_root().unwrap();
         let expected_account_root: H256 = tip_block.raw().post_account().merkle_root().unpack();
         assert_eq!(
             current_account_root, expected_account_root,
@@ -552,8 +555,8 @@ async fn test_layer1_revert() {
 
     {
         let db = chain.store().begin_transaction();
-        let tree = db.state_tree(StateContext::ReadOnly).unwrap();
-        let current_account_root = tree.calculate_root().unwrap();
+        let mut tree = BlockStateDB::from_store(&db, RWConfig::readonly()).unwrap();
+        let current_account_root = tree.finalise_root().unwrap();
         let expected_account_root: H256 = tip_block.raw().post_account().merkle_root().unpack();
         assert_eq!(
             current_account_root, expected_account_root,
@@ -672,14 +675,14 @@ async fn test_sync_blocks() {
 
     // check state
     {
-        let db = chain2.store().begin_transaction();
+        let db = &chain2.store().begin_transaction();
         let tip_block = db.get_tip_block().unwrap();
         let tip_block_number: u64 = tip_block.raw().number().unpack();
         let tip_block_hash = db.get_tip_block_hash().unwrap();
         assert_eq!(tip_block_hash, tip_block.hash().into());
         assert_eq!(tip_block_number, 3);
 
-        let tree = db.state_tree(StateContext::ReadOnly).unwrap();
+        let tree = BlockStateDB::from_store(db, RWConfig::readonly()).unwrap();
         let script_hash_a: H256 = user_script_a.hash().into();
         let id_a = tree
             .get_account_id_by_script_hash(&script_hash_a)
@@ -891,7 +894,7 @@ async fn test_rewind_to_last_valid_tip_just_after_bad_block_reverted() {
         SyncEvent::WaitChallenge { cell: _, context } => context.post_reverted_block_root,
         _ => unreachable!(),
     };
-    let db = chain.store().begin_transaction();
+    let db = &chain.store().begin_transaction();
     let last_valid_tip_block_hash = db.get_last_valid_tip_block_hash().unwrap();
     let last_valid_tip_block = db.get_last_valid_tip_block().unwrap();
     let block_smt = {
diff --git a/crates/tests/src/tests/deposit_withdrawal.rs b/crates/tests/src/tests/deposit_withdrawal.rs
index 916470ef2..4b12ee731 100644
--- a/crates/tests/src/tests/deposit_withdrawal.rs
+++ b/crates/tests/src/tests/deposit_withdrawal.rs
@@ -18,7 +18,10 @@ use gw_generator::{
     sudt::build_l2_sudt_script,
     Error,
 };
-use gw_store::{state::state_db::StateContext, traits::chain_store::ChainStore};
+use gw_store::{
+    state::{history::history_state::RWConfig, BlockStateDB},
+    traits::chain_store::ChainStore,
+};
 use gw_types::{
     core::ScriptHashType,
     packed::{
@@ -134,8 +137,7 @@ async fn test_deposit_and_withdrawal() {
     .unwrap();
     let (user_id, user_script_hash, user_addr, ckb_balance, ckb_total_supply) = {
         let mem_pool = chain.mem_pool().as_ref().unwrap().lock().await;
-        let snap = mem_pool.mem_pool_state().load();
-        let tree = snap.state().unwrap();
+        let tree = mem_pool.mem_pool_state().load_state_db();
         // check user account
         assert_eq!(
             tree.get_account_count().unwrap(),
@@ -187,8 +189,7 @@ async fn test_deposit_and_withdrawal() {
     // check tx pool state
     {
         let mem_pool = chain.mem_pool().as_ref().unwrap().lock().await;
-        let snap = mem_pool.mem_pool_state().load();
-        let state = snap.state().unwrap();
+        let state = mem_pool.mem_pool_state().load_state_db();
         assert_eq!(
             state
                 .get_account_id_by_script_hash(&user_script_hash)
@@ -232,7 +233,7 @@ async fn test_deposit_and_withdrawal() {
     );
 
     let db = chain.store().begin_transaction();
-    let tree = db.state_tree(StateContext::ReadOnly).unwrap();
+    let tree = BlockStateDB::from_store(&db, RWConfig::readonly()).unwrap();
     let ckb_balance2 = tree
         .get_sudt_balance(CKB_SUDT_ACCOUNT_ID, &user_addr)
         .unwrap();
@@ -251,8 +252,7 @@ async fn test_deposit_and_withdrawal() {
     {
         let mem_pool = chain.mem_pool().as_ref().unwrap();
         let mem_pool = mem_pool.lock().await;
-        let snap = mem_pool.mem_pool_state().load();
-        let state = snap.state().unwrap();
+        let state = mem_pool.mem_pool_state().load_state_db();
         assert_eq!(
             state
                 .get_account_id_by_script_hash(&user_script_hash)
@@ -337,8 +337,7 @@ async fn test_deposit_u128_overflow() {
     .unwrap();
 
     let mem_pool = chain.mem_pool().as_ref().unwrap().lock().await;
-    let snap = mem_pool.mem_pool_state().load();
-    let tree = snap.state().unwrap();
+    let tree = mem_pool.mem_pool_state().load_state_db();
 
     let alice_addr = tree
         .get_registry_address_by_script_hash(ETH_REGISTRY_ACCOUNT_ID, &alice_script_hash)
@@ -476,8 +475,7 @@ async fn test_overdraft() {
     {
         let mem_pool = chain.mem_pool().as_ref().unwrap();
         let mem_pool = mem_pool.lock().await;
-        let snap = mem_pool.mem_pool_state().load();
-        let state = snap.state().unwrap();
+        let state = mem_pool.mem_pool_state().load_state_db();
 
         let user_addr = state
             .get_registry_address_by_script_hash(ETH_REGISTRY_ACCOUNT_ID, &user_script_hash.into())
diff --git a/crates/tests/src/tests/export_import_block.rs b/crates/tests/src/tests/export_import_block.rs
index 98a4a6a73..6b7f0ee1b 100644
--- a/crates/tests/src/tests/export_import_block.rs
+++ b/crates/tests/src/tests/export_import_block.rs
@@ -457,7 +457,7 @@ async fn generate_and_revert_a_bad_block(
         SyncEvent::WaitChallenge { cell: _, context } => context.post_reverted_block_root,
         _ => unreachable!(),
     };
-    let db = chain.store().begin_transaction();
+    let db = &chain.store().begin_transaction();
     let last_valid_tip_block_hash = db.get_last_valid_tip_block_hash().unwrap();
     let last_valid_tip_block = db.get_last_valid_tip_block().unwrap();
     let block_smt = {
diff --git a/crates/tests/src/tests/mem_block_repackage.rs b/crates/tests/src/tests/mem_block_repackage.rs
index c7c9e5208..f9fbdb6f8 100644
--- a/crates/tests/src/tests/mem_block_repackage.rs
+++ b/crates/tests/src/tests/mem_block_repackage.rs
@@ -12,7 +12,7 @@ use gw_block_producer::{
 use gw_common::H256;
 use gw_generator::traits::StateExt;
 use gw_mem_pool::pool::OutputParam;
-use gw_store::{mem_pool_state::MemStore, traits::chain_store::ChainStore};
+use gw_store::{state::MemStateDB, traits::chain_store::ChainStore};
 use gw_types::{
     core::ScriptHashType,
     offchain::{CellInfo, DepositInfo, RollupContext},
@@ -57,12 +57,11 @@ async fn test_repackage_mem_block() {
 
     {
         let snap = chain.store().get_snapshot();
-        let mem_store = MemStore::new(snap);
-        let state = mem_store.state().unwrap();
+        let mut state = MemStateDB::from_store(snap).unwrap();
         let tip_block = chain.store().get_tip_block().unwrap();
 
         assert_eq!(
-            state.merkle_state().unwrap().as_slice(),
+            state.finalise_merkle_state().unwrap().as_slice(),
             tip_block.raw().post_account().as_slice()
         );
     }
diff --git a/crates/tests/src/tests/meta_contract_args.rs b/crates/tests/src/tests/meta_contract_args.rs
index 3bbef508a..2902a60db 100644
--- a/crates/tests/src/tests/meta_contract_args.rs
+++ b/crates/tests/src/tests/meta_contract_args.rs
@@ -24,8 +24,7 @@ async fn test_backward_compatibility() {
 
     // Deploy erc20 contract for test
     let mem_pool_state = chain.mem_pool_state().await;
-    let snap = mem_pool_state.load();
-    let mut state = snap.state().unwrap();
+    let mut state = mem_pool_state.load_state_db();
 
     let register = EthWallet::random(chain.rollup_type_hash());
     let register_id = register
@@ -74,14 +73,13 @@ async fn test_backward_compatibility() {
         .signature(sign.pack())
         .build();
 
-    mem_pool_state.store(snap.into());
+    mem_pool_state.store_state_db(state.into());
     {
         let mut mem_pool = chain.mem_pool().await;
         mem_pool.push_transaction(create_user_tx).unwrap();
     }
 
-    let snap = mem_pool_state.load();
-    let state = snap.state().unwrap();
+    let state = mem_pool_state.load_state_db();
 
     let opt_user_id = state
         .get_account_id_by_script_hash(&new_user.account_script_hash())
diff --git a/crates/tests/src/tests/polyjuice_sender_recover.rs b/crates/tests/src/tests/polyjuice_sender_recover.rs
index 3e898b511..5456cc9e8 100644
--- a/crates/tests/src/tests/polyjuice_sender_recover.rs
+++ b/crates/tests/src/tests/polyjuice_sender_recover.rs
@@ -26,8 +26,7 @@ async fn test_eth_account_creator() {
     let chain = TestChain::setup(rollup_type_script).await;
 
     let mem_pool_state = chain.mem_pool_state().await;
-    let snap = mem_pool_state.load();
-    let mut state = snap.state().unwrap();
+    let mut state = mem_pool_state.load_state_db();
 
     let creator_wallet = EthWallet::random(chain.rollup_type_hash());
     creator_wallet
@@ -35,7 +34,6 @@ async fn test_eth_account_creator() {
         .unwrap();
 
     let polyjuice_account = PolyjuiceAccount::create(chain.rollup_type_hash(), &mut state).unwrap();
-    state.submit_tree_to_mem_block();
 
     let account_ctx = EthAccountContext::new(
         chain.chain_id(),
@@ -89,14 +87,13 @@ async fn test_eth_account_creator() {
         .build_batch_create_tx(&state, recovered_account_scripts)
         .unwrap();
 
-    mem_pool_state.store(snap.into());
+    mem_pool_state.store_state_db(state.into());
     {
         let mut mem_pool = chain.mem_pool().await;
         mem_pool.push_transaction(batch_create_tx).unwrap();
     }
 
-    let snap = mem_pool_state.load();
-    let state = snap.state().unwrap();
+    let state = mem_pool_state.load_state_db();
 
     for wallet in new_users_wallet {
         let opt_user_script_hash = state
diff --git a/crates/tests/src/tests/restore_mem_block.rs b/crates/tests/src/tests/restore_mem_block.rs
index a95faae85..ffb0cf554 100644
--- a/crates/tests/src/tests/restore_mem_block.rs
+++ b/crates/tests/src/tests/restore_mem_block.rs
@@ -14,7 +14,8 @@ use gw_common::builtins::ETH_REGISTRY_ACCOUNT_ID;
 use gw_common::registry_address::RegistryAddress;
 use gw_common::{state::State, H256};
 use gw_rpc_server::registry::Registry;
-use gw_store::state::state_db::StateContext;
+use gw_store::state::history::history_state::RWConfig;
+use gw_store::state::BlockStateDB;
 use gw_types::packed::{
     DepositInfoVec, DepositRequest, Fee, L2Transaction, RawL2Transaction, RawWithdrawalRequest,
     SUDTArgs, SUDTTransfer, Script, WithdrawalRequest, WithdrawalRequestExtra,
@@ -118,7 +119,7 @@ async fn test_restore_mem_block() {
     let random_txs: Vec<_> = {
         let tx_accounts = accounts.iter().skip(withdrawal_count as usize);
         let db = chain.store().begin_transaction();
-        let state = db.state_tree(StateContext::ReadOnly).unwrap();
+        let state = BlockStateDB::from_store(&db, RWConfig::readonly()).unwrap();
         tx_accounts
             .map(|account_script| {
                 let from_id = state
diff --git a/crates/tests/src/tests/rpc_server/execute_l2transaction.rs b/crates/tests/src/tests/rpc_server/execute_l2transaction.rs
index 0373d3b1f..4d51cb668 100644
--- a/crates/tests/src/tests/rpc_server/execute_l2transaction.rs
+++ b/crates/tests/src/tests/rpc_server/execute_l2transaction.rs
@@ -38,8 +38,7 @@ async fn test_polyjuice_erc20_tx() {
     assert!(RegistryAddress::from_slice(&block_producer).is_some());
 
     let mem_pool_state = chain.mem_pool_state().await;
-    let snap = mem_pool_state.load();
-    let mut state = snap.state().unwrap();
+    let mut state = mem_pool_state.load_state_db();
 
     let test_wallet = EthWallet::random(chain.rollup_type_hash());
     let test_account_id = test_wallet
@@ -48,8 +47,6 @@ async fn test_polyjuice_erc20_tx() {
 
     let polyjuice_account = PolyjuiceAccount::create(chain.rollup_type_hash(), &mut state).unwrap();
 
-    state.submit_tree_to_mem_block();
-
     // Deploy erc20 contract
     let deploy_args = SudtErc20ArgsBuilder::deploy(CKB_SUDT_ACCOUNT_ID, 18).finish();
     let raw_tx = RawL2Transaction::new_builder()
@@ -61,7 +58,7 @@ async fn test_polyjuice_erc20_tx() {
         .build();
     let deploy_tx = test_wallet.sign_polyjuice_tx(&state, raw_tx).unwrap();
 
-    mem_pool_state.store(snap.into());
+    mem_pool_state.store_state_db(state.into());
     let run_result = rpc_server.execute_l2transaction(&deploy_tx).await.unwrap();
 
     let logs = run_result.logs.into_iter().map(Into::into);
@@ -86,8 +83,7 @@ async fn test_polyjuice_tx_from_id_zero() {
     assert!(RegistryAddress::from_slice(&block_producer).is_some());
 
     let mem_pool_state = chain.mem_pool_state().await;
-    let snap = mem_pool_state.load();
-    let mut state = snap.state().unwrap();
+    let mut state = mem_pool_state.load_state_db();
 
     let deployer_wallet = EthWallet::random(chain.rollup_type_hash());
     let deployer_id = deployer_wallet
@@ -102,8 +98,6 @@ async fn test_polyjuice_tx_from_id_zero() {
 
     let polyjuice_account = PolyjuiceAccount::create(chain.rollup_type_hash(), &mut state).unwrap();
 
-    state.submit_tree_to_mem_block();
-
     // Deploy erc20 for test
     let deploy_args = SudtErc20ArgsBuilder::deploy(CKB_SUDT_ACCOUNT_ID, 18).finish();
     let raw_tx = RawL2Transaction::new_builder()
@@ -117,14 +111,13 @@ async fn test_polyjuice_tx_from_id_zero() {
     let deploy_tx = deployer_wallet.sign_polyjuice_tx(&state, raw_tx).unwrap();
     let deploy_tx_hash: H256 = deploy_tx.hash().into();
 
-    mem_pool_state.store(snap.into());
+    mem_pool_state.store_state_db(state.into());
     {
         let mut mem_pool = chain.mem_pool().await;
         mem_pool.push_transaction(deploy_tx).unwrap();
     }
 
-    let snap = mem_pool_state.load();
-    let mut state = snap.state().unwrap();
+    let mut state = mem_pool_state.load_state_db();
 
     let system_log = PolyjuiceSystemLog::parse_from_tx_hash(&chain, deploy_tx_hash).unwrap();
     assert_eq!(system_log.status_code, 0);
@@ -166,7 +159,7 @@ async fn test_polyjuice_tx_from_id_zero() {
         .build();
     let balance_tx = test_wallet.sign_polyjuice_tx(&state, raw_tx).unwrap();
 
-    mem_pool_state.store(snap.into());
+    mem_pool_state.store_state_db(state.into());
     let run_result = rpc_server.execute_l2transaction(&balance_tx).await.unwrap();
 
     assert_eq!(
@@ -192,8 +185,7 @@ async fn test_invalid_polyjuice_tx_from_id_zero() {
     assert!(RegistryAddress::from_slice(&block_producer).is_some());
 
     let mem_pool_state = chain.mem_pool_state().await;
-    let snap = mem_pool_state.load();
-    let mut state = snap.state().unwrap();
+    let mut state = mem_pool_state.load_state_db();
 
     let deployer_wallet = EthWallet::random(chain.rollup_type_hash());
     let deployer_id = deployer_wallet
@@ -202,8 +194,6 @@ async fn test_invalid_polyjuice_tx_from_id_zero() {
 
     let polyjuice_account = PolyjuiceAccount::create(chain.rollup_type_hash(), &mut state).unwrap();
 
-    state.submit_tree_to_mem_block();
-
     // Deploy erc20 for test
     let deploy_args = SudtErc20ArgsBuilder::deploy(CKB_SUDT_ACCOUNT_ID, 18).finish();
     let raw_tx = RawL2Transaction::new_builder()
@@ -219,7 +209,7 @@ async fn test_invalid_polyjuice_tx_from_id_zero() {
         .unwrap();
     let deploy_tx_hash: H256 = deploy_tx.hash().into();
 
-    mem_pool_state.store(snap.into());
+    mem_pool_state.store_state_db(state.into());
     {
         let mut mem_pool = chain.mem_pool().await;
         mem_pool.push_transaction(deploy_tx).unwrap();
@@ -228,8 +218,7 @@ async fn test_invalid_polyjuice_tx_from_id_zero() {
     let system_log = PolyjuiceSystemLog::parse_from_tx_hash(&chain, deploy_tx_hash).unwrap();
     assert_eq!(system_log.status_code, 0);
 
-    let snap = mem_pool_state.load();
-    let state = snap.state().unwrap();
+    let state = mem_pool_state.load_state_db();
 
     let test_wallet = EthWallet::random(chain.rollup_type_hash());
     let erc20_contract_account_id = system_log.contract_account_id(&state).unwrap();
@@ -307,13 +296,11 @@ async fn test_invalid_polyjuice_tx_from_id_zero() {
     assert!(err.to_string().contains(&expected_err.to_string()));
 
     // Insufficient balance
-    let snap = mem_pool_state.load();
-    let mut state = snap.state().unwrap();
+    let mut state = mem_pool_state.load_state_db();
 
     let balance = 100u32.into();
     test_wallet.mint_ckb_sudt(&mut state, balance).unwrap();
-    state.submit_tree_to_mem_block();
-    mem_pool_state.store(snap.into());
+    mem_pool_state.store_state_db(state.into());
 
     let err = rpc_server
         .execute_l2transaction(&balance_tx)
@@ -325,13 +312,11 @@ async fn test_invalid_polyjuice_tx_from_id_zero() {
     assert!(err.to_string().contains(&expected_err));
 
     // Registered to different script
-    let snap = mem_pool_state.load();
-    let mut state = snap.state().unwrap();
+    let mut state = mem_pool_state.load_state_db();
     state
         .mapping_registry_address_to_script_hash(test_wallet.reg_address().to_owned(), H256::one())
         .unwrap();
-    state.submit_tree_to_mem_block();
-    mem_pool_state.store(snap.into());
+    mem_pool_state.store_state_db(state.into());
 
     let err = rpc_server
         .execute_l2transaction(&balance_tx)
diff --git a/crates/tests/src/tests/rpc_server/execute_l2transaction/block_max_cycles_limit.rs b/crates/tests/src/tests/rpc_server/execute_l2transaction/block_max_cycles_limit.rs
index aa5ccfb8d..eba6ac62b 100644
--- a/crates/tests/src/tests/rpc_server/execute_l2transaction/block_max_cycles_limit.rs
+++ b/crates/tests/src/tests/rpc_server/execute_l2transaction/block_max_cycles_limit.rs
@@ -50,8 +50,7 @@ async fn test_block_max_cycles_limit() {
     assert!(RegistryAddress::from_slice(&block_producer).is_some());
 
     let mem_pool_state = chain.mem_pool_state().await;
-    let snap = mem_pool_state.load();
-    let mut state = snap.state().unwrap();
+    let mut state = mem_pool_state.load_state_db();
 
     let test_wallet = EthWallet::random(chain.rollup_type_hash());
     let test_account_id = test_wallet
@@ -60,8 +59,6 @@ async fn test_block_max_cycles_limit() {
 
     let polyjuice_account = PolyjuiceAccount::create(chain.rollup_type_hash(), &mut state).unwrap();
 
-    state.submit_tree_to_mem_block();
-
     // Deploy erc20 contract
     let deploy_args = SudtErc20ArgsBuilder::deploy(CKB_SUDT_ACCOUNT_ID, 18).finish();
     let raw_tx = RawL2Transaction::new_builder()
@@ -73,7 +70,7 @@ async fn test_block_max_cycles_limit() {
         .build();
     let deploy_tx = test_wallet.sign_polyjuice_tx(&state, raw_tx).unwrap();
 
-    mem_pool_state.store(snap.into());
+    mem_pool_state.store_state_db(state);
     let run_result = rpc_server.execute_l2transaction(&deploy_tx).await.unwrap();
 
     let logs = run_result.logs.into_iter().map(Into::into);
@@ -105,8 +102,7 @@ async fn test_block_max_cycles_limit() {
     };
 
     let mem_pool_state = chain.mem_pool_state().await;
-    let snap = mem_pool_state.load();
-    let mut state = snap.state().unwrap();
+    let mut state = mem_pool_state.load_state_db();
 
     let test_wallet = EthWallet::random(chain.rollup_type_hash());
     let test_account_id = test_wallet
@@ -114,7 +110,6 @@ async fn test_block_max_cycles_limit() {
         .unwrap();
 
     let polyjuice_account = PolyjuiceAccount::create(chain.rollup_type_hash(), &mut state).unwrap();
-    state.submit_tree_to_mem_block();
 
     let raw_tx = RawL2Transaction::new_builder()
         .chain_id(chain.chain_id().pack())
@@ -125,7 +120,7 @@ async fn test_block_max_cycles_limit() {
         .build();
     let deploy_tx = test_wallet.sign_polyjuice_tx(&state, raw_tx).unwrap();
 
-    mem_pool_state.store(snap.into());
+    mem_pool_state.store_state_db(state.into());
     let err = rpc_server
         .execute_l2transaction(&deploy_tx)
         .await
diff --git a/crates/tests/src/tests/rpc_server/execute_raw_l2transaction.rs b/crates/tests/src/tests/rpc_server/execute_raw_l2transaction.rs
index 320a306f6..5dbaf6a8f 100644
--- a/crates/tests/src/tests/rpc_server/execute_raw_l2transaction.rs
+++ b/crates/tests/src/tests/rpc_server/execute_raw_l2transaction.rs
@@ -6,6 +6,7 @@ use gw_common::{
     H256,
 };
 use gw_generator::account_lock_manage::secp256k1::Secp256k1Eth;
+use gw_store::state::{history::history_state::RWConfig, BlockStateDB};
 use gw_types::{
     bytes::Bytes,
     packed::{
@@ -44,8 +45,7 @@ async fn test_polyjuice_erc20_tx() {
     assert!(RegistryAddress::from_slice(&block_producer).is_some());
 
     let mem_pool_state = chain.mem_pool_state().await;
-    let snap = mem_pool_state.load();
-    let mut state = snap.state().unwrap();
+    let mut state = mem_pool_state.load_state_db();
 
     let test_wallet = EthWallet::random(chain.rollup_type_hash());
     let test_account_id = test_wallet
@@ -54,8 +54,6 @@ async fn test_polyjuice_erc20_tx() {
 
     let polyjuice_account = PolyjuiceAccount::create(chain.rollup_type_hash(), &mut state).unwrap();
 
-    state.submit_tree_to_mem_block();
-
     // Deploy erc20 contract
     let deploy_args = SudtErc20ArgsBuilder::deploy(CKB_SUDT_ACCOUNT_ID, 18).finish();
     let raw_tx = RawL2Transaction::new_builder()
@@ -67,7 +65,7 @@ async fn test_polyjuice_erc20_tx() {
         .build();
 
     let reg_addr_bytes = test_wallet.reg_address().to_bytes().into();
-    mem_pool_state.store(snap.into());
+    mem_pool_state.store_state_db(state.into());
 
     let run_result = rpc_server
         .execute_raw_l2transaction(&raw_tx, None, Some(reg_addr_bytes))
@@ -96,8 +94,7 @@ async fn test_polyjuice_tx_from_id_zero() {
     assert!(RegistryAddress::from_slice(&block_producer).is_some());
 
     let mem_pool_state = chain.mem_pool_state().await;
-    let snap = mem_pool_state.load();
-    let mut state = snap.state().unwrap();
+    let mut state = mem_pool_state.load_state_db();
 
     let deployer_wallet = EthWallet::random(chain.rollup_type_hash());
     let deployer_id = deployer_wallet
@@ -112,8 +109,6 @@ async fn test_polyjuice_tx_from_id_zero() {
 
     let polyjuice_account = PolyjuiceAccount::create(chain.rollup_type_hash(), &mut state).unwrap();
 
-    state.submit_tree_to_mem_block();
-
     // Deploy erc20 for test
     let deploy_args = SudtErc20ArgsBuilder::deploy(CKB_SUDT_ACCOUNT_ID, 18).finish();
     let raw_tx = RawL2Transaction::new_builder()
@@ -127,7 +122,7 @@ async fn test_polyjuice_tx_from_id_zero() {
     let deploy_tx = deployer_wallet.sign_polyjuice_tx(&state, raw_tx).unwrap();
     let deploy_tx_hash: H256 = deploy_tx.hash().into();
 
-    mem_pool_state.store(snap.into());
+    mem_pool_state.store_state_db(state.into());
     {
         let mut mem_pool = chain.mem_pool().await;
         mem_pool.push_transaction(deploy_tx).unwrap();
@@ -136,8 +131,7 @@ async fn test_polyjuice_tx_from_id_zero() {
     let system_log = PolyjuiceSystemLog::parse_from_tx_hash(&chain, deploy_tx_hash).unwrap();
     assert_eq!(system_log.status_code, 0);
 
-    let snap = mem_pool_state.load();
-    let mut state = snap.state().unwrap();
+    let mut state = mem_pool_state.load_state_db();
 
     // Check erc20 balance with existing sender
     let erc20_contract_account_id = system_log.contract_account_id(&state).unwrap();
@@ -168,9 +162,8 @@ async fn test_polyjuice_tx_from_id_zero() {
         .mint_sudt(&mut state, CKB_SUDT_ACCOUNT_ID, test_balance)
         .unwrap();
 
-    mem_pool_state.store(snap.into());
-    let snap = mem_pool_state.load();
-    let state = snap.state().unwrap();
+    mem_pool_state.store_state_db(state.into());
+    let state = mem_pool_state.load_state_db();
 
     let erc20_contract_account_id = system_log.contract_account_id(&state).unwrap();
     let balance_args = SudtErc20ArgsBuilder::balance_of(&test_wallet.registry_address).finish();
@@ -219,8 +212,7 @@ async fn test_polyjuice_tx_from_id_zero_with_block_number() {
 
     // Deploy erc20 contract for test
     let mem_pool_state = chain.mem_pool_state().await;
-    let snap = mem_pool_state.load();
-    let state = snap.state().unwrap();
+    let state = mem_pool_state.load_state_db();
 
     let pre_block1_balance = state
         .get_sudt_balance(CKB_SUDT_ACCOUNT_ID, test_wallet.reg_address())
@@ -272,8 +264,7 @@ async fn test_polyjuice_tx_from_id_zero_with_block_number() {
         mem_pool.push_transaction(deploy_tx).unwrap();
     }
 
-    let snap = mem_pool_state.load();
-    let state = snap.state().unwrap();
+    let state = mem_pool_state.load_state_db();
 
     // Depoly erc20 contract
     let polyjuice_account_id = state
@@ -300,8 +291,7 @@ async fn test_polyjuice_tx_from_id_zero_with_block_number() {
     let system_log = PolyjuiceSystemLog::parse_from_tx_hash(&chain, deploy_tx_hash).unwrap();
     assert_eq!(system_log.status_code, 0);
 
-    let snap = mem_pool_state.load();
-    let state = snap.state().unwrap();
+    let state = mem_pool_state.load_state_db();
 
     let erc20_contract_account_id = system_log.contract_account_id(&state).unwrap();
     let erc20_contract_script_hash = state.get_script_hash(erc20_contract_account_id).unwrap();
@@ -320,8 +310,7 @@ async fn test_polyjuice_tx_from_id_zero_with_block_number() {
     let block_producer: Bytes = chain.last_valid_block().raw().block_producer().unpack();
     assert!(RegistryAddress::from_slice(&block_producer).is_some());
 
-    let snap = mem_pool_state.load();
-    let state = snap.state().unwrap();
+    let state = mem_pool_state.load_state_db();
 
     let expect_polyjuice_account_id = state
         .get_account_id_by_script_hash(&polyjuice_account.hash().into())
@@ -357,8 +346,7 @@ async fn test_polyjuice_tx_from_id_zero_with_block_number() {
         mem_pool.push_transaction(transfer_tx).unwrap();
     }
 
-    let snap = mem_pool_state.load();
-    let state = snap.state().unwrap();
+    let state = mem_pool_state.load_state_db();
 
     let to_balance = state
         .get_sudt_balance(CKB_SUDT_ACCOUNT_ID, to_wallet.reg_address())
@@ -396,17 +384,13 @@ async fn test_polyjuice_tx_from_id_zero_with_block_number() {
         .unwrap();
 
     let db = chain.store().begin_transaction();
-    let pre_block1_hist_state = db
-        .state_tree(gw_store::state::state_db::StateContext::ReadOnlyHistory(1))
-        .unwrap();
+    let pre_block1_hist_state = BlockStateDB::from_store(&db, RWConfig::history_block(1)).unwrap();
     let hist_balance = pre_block1_hist_state
         .get_sudt_balance(CKB_SUDT_ACCOUNT_ID, test_wallet.reg_address())
         .unwrap();
     assert_eq!(hist_balance, pre_block1_balance);
 
-    let post_block1_hist_state = db
-        .state_tree(gw_store::state::state_db::StateContext::ReadOnlyHistory(2))
-        .unwrap();
+    let post_block1_hist_state = BlockStateDB::from_store(&db, RWConfig::history_block(2)).unwrap();
     let hist_balance = post_block1_hist_state
         .get_sudt_balance(CKB_SUDT_ACCOUNT_ID, test_wallet.reg_address())
         .unwrap();
@@ -474,8 +458,7 @@ async fn test_invalid_registry_address() {
     assert!(RegistryAddress::from_slice(&block_producer).is_some());
 
     let mem_pool_state = chain.mem_pool_state().await;
-    let snap = mem_pool_state.load();
-    let mut state = snap.state().unwrap();
+    let mut state = mem_pool_state.load_state_db();
 
     let deployer_wallet = EthWallet::random(chain.rollup_type_hash());
     let deployer_id = deployer_wallet
@@ -490,8 +473,6 @@ async fn test_invalid_registry_address() {
 
     let polyjuice_account = PolyjuiceAccount::create(chain.rollup_type_hash(), &mut state).unwrap();
 
-    state.submit_tree_to_mem_block();
-
     // Deploy erc20 for test
     let deploy_args = SudtErc20ArgsBuilder::deploy(CKB_SUDT_ACCOUNT_ID, 18).finish();
     let raw_tx = RawL2Transaction::new_builder()
@@ -505,7 +486,7 @@ async fn test_invalid_registry_address() {
     let deploy_tx = deployer_wallet.sign_polyjuice_tx(&state, raw_tx).unwrap();
     let deploy_tx_hash: H256 = deploy_tx.hash().into();
 
-    mem_pool_state.store(snap.into());
+    mem_pool_state.store_state_db(state.into());
     {
         let mut mem_pool = chain.mem_pool().await;
         mem_pool.push_transaction(deploy_tx).unwrap();
@@ -514,8 +495,7 @@ async fn test_invalid_registry_address() {
     let system_log = PolyjuiceSystemLog::parse_from_tx_hash(&chain, deploy_tx_hash).unwrap();
     assert_eq!(system_log.status_code, 0);
 
-    let snap = mem_pool_state.load();
-    let state = snap.state().unwrap();
+    let state = mem_pool_state.load_state_db();
 
     // No registry address
     let erc20_contract_account_id = system_log.contract_account_id(&state).unwrap();
diff --git a/crates/tests/src/tests/rpc_server/execute_raw_l2transaction/block_max_cycles_limit.rs b/crates/tests/src/tests/rpc_server/execute_raw_l2transaction/block_max_cycles_limit.rs
index 810f3dc8d..031b2ee10 100644
--- a/crates/tests/src/tests/rpc_server/execute_raw_l2transaction/block_max_cycles_limit.rs
+++ b/crates/tests/src/tests/rpc_server/execute_raw_l2transaction/block_max_cycles_limit.rs
@@ -50,8 +50,7 @@ async fn test_block_max_cycles_limit() {
     assert!(RegistryAddress::from_slice(&block_producer).is_some());
 
     let mem_pool_state = chain.mem_pool_state().await;
-    let snap = mem_pool_state.load();
-    let mut state = snap.state().unwrap();
+    let mut state = mem_pool_state.load_state_db();
 
     let test_wallet = EthWallet::random(chain.rollup_type_hash());
     let test_account_id = test_wallet
@@ -60,8 +59,6 @@ async fn test_block_max_cycles_limit() {
 
     let polyjuice_account = PolyjuiceAccount::create(chain.rollup_type_hash(), &mut state).unwrap();
 
-    state.submit_tree_to_mem_block();
-
     // Deploy erc20 contract
     let deploy_args = SudtErc20ArgsBuilder::deploy(CKB_SUDT_ACCOUNT_ID, 18).finish();
     let raw_tx = RawL2Transaction::new_builder()
@@ -73,7 +70,7 @@ async fn test_block_max_cycles_limit() {
         .build();
     let reg_addr_bytes = test_wallet.reg_address().to_bytes().into();
 
-    mem_pool_state.store(snap.into());
+    mem_pool_state.store_state_db(state.into());
     let run_result = rpc_server
         .execute_raw_l2transaction(&raw_tx, None, Some(reg_addr_bytes))
         .await
@@ -108,8 +105,7 @@ async fn test_block_max_cycles_limit() {
     };
 
     let mem_pool_state = chain.mem_pool_state().await;
-    let snap = mem_pool_state.load();
-    let mut state = snap.state().unwrap();
+    let mut state = mem_pool_state.load_state_db();
 
     let test_wallet = EthWallet::random(chain.rollup_type_hash());
     let test_account_id = test_wallet
@@ -117,7 +113,6 @@ async fn test_block_max_cycles_limit() {
         .unwrap();
 
     let polyjuice_account = PolyjuiceAccount::create(chain.rollup_type_hash(), &mut state).unwrap();
-    state.submit_tree_to_mem_block();
 
     let raw_tx = RawL2Transaction::new_builder()
         .chain_id(chain.chain_id().pack())
@@ -128,7 +123,7 @@ async fn test_block_max_cycles_limit() {
         .build();
     let reg_addr_bytes = test_wallet.reg_address().to_bytes().into();
 
-    mem_pool_state.store(snap.into());
+    mem_pool_state.store_state_db(state.into());
     let err = rpc_server
         .execute_raw_l2transaction(&raw_tx, None, Some(reg_addr_bytes))
         .await
diff --git a/crates/tests/src/tests/rpc_server/submit_l2transaction.rs b/crates/tests/src/tests/rpc_server/submit_l2transaction.rs
index a72e700dd..ec294d766 100644
--- a/crates/tests/src/tests/rpc_server/submit_l2transaction.rs
+++ b/crates/tests/src/tests/rpc_server/submit_l2transaction.rs
@@ -33,8 +33,7 @@ async fn test_polyjuice_erc20_tx() {
     let rpc_server = RPCServer::build(&chain, None).await.unwrap();
 
     let mem_pool_state = chain.mem_pool_state().await;
-    let snap = mem_pool_state.load();
-    let mut state = snap.state().unwrap();
+    let mut state = mem_pool_state.load_state_db();
 
     let creator_wallet = EthWallet::random(chain.rollup_type_hash());
     let creator_account_id = creator_wallet
@@ -42,7 +41,6 @@ async fn test_polyjuice_erc20_tx() {
         .unwrap();
 
     let polyjuice_account = PolyjuiceAccount::create(chain.rollup_type_hash(), &mut state).unwrap();
-    state.submit_tree_to_mem_block();
 
     let deploy_args = SudtErc20ArgsBuilder::deploy(CKB_SUDT_ACCOUNT_ID, 18).finish();
     let raw_tx = RawL2Transaction::new_builder()
@@ -54,7 +52,7 @@ async fn test_polyjuice_erc20_tx() {
         .build();
     let deploy_tx = creator_wallet.sign_polyjuice_tx(&state, raw_tx).unwrap();
 
-    mem_pool_state.store(snap.into());
+    mem_pool_state.store_state_db(state.into());
     let deploy_tx_hash = rpc_server
         .submit_l2transaction(&deploy_tx)
         .await
@@ -67,8 +65,7 @@ async fn test_polyjuice_erc20_tx() {
     let system_log = PolyjuiceSystemLog::parse_from_tx_hash(&chain, deploy_tx_hash).unwrap();
     assert_eq!(system_log.status_code, 0);
 
-    let snap = mem_pool_state.load();
-    let state = snap.state().unwrap();
+    let state = mem_pool_state.load_state_db();
 
     let erc20_contract_account_id = system_log.contract_account_id(&state).unwrap();
     let to_wallet = EthWallet::random(chain.rollup_type_hash());
@@ -96,8 +93,7 @@ async fn test_polyjuice_erc20_tx() {
     let system_log = PolyjuiceSystemLog::parse_from_tx_hash(&chain, deploy_tx_hash).unwrap();
     assert_eq!(system_log.status_code, 0);
 
-    let snap = mem_pool_state.load();
-    let state = snap.state().unwrap();
+    let state = mem_pool_state.load_state_db();
 
     let balance = state
         .get_sudt_balance(CKB_SUDT_ACCOUNT_ID, to_wallet.reg_address())
@@ -113,8 +109,7 @@ async fn test_in_queue_query_with_signature_hash() {
     let chain = TestChain::setup(rollup_type_script).await;
 
     let mem_pool_state = chain.mem_pool_state().await;
-    let snap = mem_pool_state.load();
-    let mut state = snap.state().unwrap();
+    let mut state = mem_pool_state.load_state_db();
 
     let creator_wallet = EthWallet::random(chain.rollup_type_hash());
     creator_wallet
@@ -129,7 +124,6 @@ async fn test_in_queue_query_with_signature_hash() {
     let test_wallet = EthWallet::random(chain.rollup_type_hash());
     let balance: U256 = 1000000u128.into();
     test_wallet.mint_ckb_sudt(&mut state, balance).unwrap();
-    state.submit_tree_to_mem_block();
 
     let deploy_args = SudtErc20ArgsBuilder::deploy(CKB_SUDT_ACCOUNT_ID, 18).finish();
     let raw_tx = RawL2Transaction::new_builder()
@@ -147,7 +141,7 @@ async fn test_in_queue_query_with_signature_hash() {
     };
     let deploy_tx = test_wallet.sign_polyjuice_tx(&state, raw_tx).unwrap();
 
-    mem_pool_state.store(snap.into());
+    mem_pool_state.store_state_db(state.into());
     let signature_hash = {
         let mut hasher = new_blake2b();
         let sig: Bytes = deploy_tx.signature().unpack();
@@ -181,8 +175,7 @@ async fn test_polyjuice_tx_from_id_zero() {
     let chain = TestChain::setup(rollup_type_script).await;
 
     let mem_pool_state = chain.mem_pool_state().await;
-    let snap = mem_pool_state.load();
-    let mut state = snap.state().unwrap();
+    let mut state = mem_pool_state.load_state_db();
 
     let creator_wallet = EthWallet::random(chain.rollup_type_hash());
     creator_wallet
@@ -197,7 +190,6 @@ async fn test_polyjuice_tx_from_id_zero() {
     let test_wallet = EthWallet::random(chain.rollup_type_hash());
     let balance: U256 = 1000000u128.into();
     test_wallet.mint_ckb_sudt(&mut state, balance).unwrap();
-    state.submit_tree_to_mem_block();
 
     let deploy_args = SudtErc20ArgsBuilder::deploy(CKB_SUDT_ACCOUNT_ID, 18).finish();
     let raw_tx = RawL2Transaction::new_builder()
@@ -217,7 +209,7 @@ async fn test_polyjuice_tx_from_id_zero() {
     };
     let deploy_tx = test_wallet.sign_polyjuice_tx(&state, raw_tx).unwrap();
 
-    mem_pool_state.store(snap.into());
+    mem_pool_state.store_state_db(state.into());
     rpc_server.submit_l2transaction(&deploy_tx).await.unwrap();
     wait_tx_committed(&chain, &deploy_tx_hash, Duration::from_secs(30))
         .await
@@ -232,8 +224,7 @@ async fn test_polyjuice_tx_from_id_zero() {
         mem_block_txs_count + 2, // one deploy tx and create account tx
     );
 
-    let snap = mem_pool_state.load();
-    let state = snap.state().unwrap();
+    let state = mem_pool_state.load_state_db();
 
     let test_account_id = state
         .get_account_id_by_script_hash(&test_wallet.account_script_hash())
@@ -257,13 +248,11 @@ async fn test_polyjuice_tx_from_id_zero() {
     assert!(balance > balance_after);
 
     // From existing account
-    let snap = mem_pool_state.load();
-    let mut state = snap.state().unwrap();
+    let mut state = mem_pool_state.load_state_db();
 
     let test_wallet = EthWallet::random(chain.rollup_type_hash());
     let balance: U256 = 1000000u128.into();
     let expected_id = test_wallet.create_account(&mut state, balance).unwrap();
-    state.submit_tree_to_mem_block();
 
     let mem_block_txs_count = chain.mem_pool().await.mem_block().txs().len();
 
@@ -282,7 +271,7 @@ async fn test_polyjuice_tx_from_id_zero() {
         raw.hash().into()
     };
     let deploy_tx = test_wallet.sign_polyjuice_tx(&state, raw_tx).unwrap();
-    mem_pool_state.store(snap.into());
+    mem_pool_state.store_state_db(state.into());
 
     rpc_server.submit_l2transaction(&deploy_tx).await.unwrap();
     wait_tx_committed(&chain, &deploy_tx_hash, Duration::from_secs(30))
@@ -303,8 +292,7 @@ async fn test_polyjuice_tx_from_id_zero() {
         "should not push create account tx"
     );
 
-    let snap = mem_pool_state.load();
-    let state = snap.state().unwrap();
+    let state = mem_pool_state.load_state_db();
 
     let balance_after = state
         .get_sudt_balance(CKB_SUDT_ACCOUNT_ID, test_wallet.reg_address())
@@ -320,8 +308,7 @@ async fn test_invalid_polyjuice_tx_from_id_zero() {
     let chain = TestChain::setup(rollup_type_script).await;
 
     let mem_pool_state = chain.mem_pool_state().await;
-    let snap = mem_pool_state.load();
-    let mut state = snap.state().unwrap();
+    let mut state = mem_pool_state.load_state_db();
 
     let creator_wallet = EthWallet::random(chain.rollup_type_hash());
     creator_wallet
@@ -336,7 +323,6 @@ async fn test_invalid_polyjuice_tx_from_id_zero() {
     let deployer_id = deployer_wallet
         .create_account(&mut state, 1000000u128.into())
         .unwrap();
-    state.submit_tree_to_mem_block();
 
     let expected_txs_count = chain.mem_pool().await.mem_block().txs().len();
 
@@ -355,7 +341,7 @@ async fn test_invalid_polyjuice_tx_from_id_zero() {
         .sign_polyjuice_tx(&state, raw_tx.clone())
         .unwrap();
 
-    mem_pool_state.store(snap.into());
+    mem_pool_state.store_state_db(state.into());
     let err = rpc_server_no_creator
         .submit_l2transaction(&deploy_tx)
         .await
@@ -365,8 +351,7 @@ async fn test_invalid_polyjuice_tx_from_id_zero() {
     let expected_err = "tx from zero is disabled";
     assert!(err.to_string().contains(&expected_err));
 
-    let snap = mem_pool_state.load();
-    let state = snap.state().unwrap();
+    let state = mem_pool_state.load_state_db();
 
     // Mismatch chain id
     let bad_chain_id_raw_tx = raw_tx
@@ -433,18 +418,16 @@ async fn test_invalid_polyjuice_tx_from_id_zero() {
         .unwrap();
 
     // Insufficient balance
-    let snap = mem_pool_state.load();
-    let mut state = snap.state().unwrap();
+    let mut state = mem_pool_state.load_state_db();
 
     let test_wallet = EthWallet::random(chain.rollup_type_hash());
     let balance: U256 = 100u32.into();
     test_wallet.mint_ckb_sudt(&mut state, balance).unwrap();
-    state.submit_tree_to_mem_block();
 
     let insufficient_balance_deploy_tx = test_wallet
         .sign_polyjuice_tx(&state, raw_tx.clone())
         .unwrap();
-    mem_pool_state.store(snap.into());
+    mem_pool_state.store_state_db(state.into());
 
     rpc_server
         .submit_l2transaction(&insufficient_balance_deploy_tx)
@@ -452,8 +435,7 @@ async fn test_invalid_polyjuice_tx_from_id_zero() {
         .unwrap();
 
     // Registered to different script
-    let snap = mem_pool_state.load();
-    let mut state = snap.state().unwrap();
+    let mut state = mem_pool_state.load_state_db();
 
     let test_wallet = EthWallet::random(chain.rollup_type_hash());
     let balance: U256 = 9999999u128.into();
@@ -461,18 +443,16 @@ async fn test_invalid_polyjuice_tx_from_id_zero() {
     state
         .mapping_registry_address_to_script_hash(test_wallet.reg_address().to_owned(), H256::one())
         .unwrap();
-    state.submit_tree_to_mem_block();
 
     let different_script_deploy_tx = test_wallet.sign_polyjuice_tx(&state, raw_tx).unwrap();
-    mem_pool_state.store(snap.into());
+    mem_pool_state.store_state_db(state.into());
 
     rpc_server
         .submit_l2transaction(&different_script_deploy_tx)
         .await
         .unwrap();
 
-    let snap = mem_pool_state.load();
-    let mut state = snap.state().unwrap();
+    let mut state = mem_pool_state.load_state_db();
 
     // Account has tx history (nonce isn't zero)
     let test_wallet = EthWallet::random(chain.rollup_type_hash());
@@ -480,7 +460,6 @@ async fn test_invalid_polyjuice_tx_from_id_zero() {
         .create_account(&mut state, 10000000u128.into())
         .unwrap();
     state.set_nonce(test_account_id, 1).unwrap();
-    state.submit_tree_to_mem_block();
 
     let deploy_args = SudtErc20ArgsBuilder::deploy(CKB_SUDT_ACCOUNT_ID, 18).finish();
     let raw_tx = RawL2Transaction::new_builder()
@@ -492,7 +471,7 @@ async fn test_invalid_polyjuice_tx_from_id_zero() {
         .build();
     let bad_deploy_tx = test_wallet.sign_polyjuice_tx(&state, raw_tx).unwrap();
 
-    mem_pool_state.store(snap.into());
+    mem_pool_state.store_state_db(state.into());
     let err = rpc_server
         .submit_l2transaction(&bad_deploy_tx)
         .await
diff --git a/crates/tests/src/tests/rpc_server/submit_l2transaction/block_max_cycles_limit.rs b/crates/tests/src/tests/rpc_server/submit_l2transaction/block_max_cycles_limit.rs
index b09a9204a..de9a071e3 100644
--- a/crates/tests/src/tests/rpc_server/submit_l2transaction/block_max_cycles_limit.rs
+++ b/crates/tests/src/tests/rpc_server/submit_l2transaction/block_max_cycles_limit.rs
@@ -74,8 +74,7 @@ async fn test_block_max_cycles_limit() {
     chain.produce_block(deposit_info_vec, vec![]).await.unwrap();
 
     let mem_pool_state = chain.mem_pool_state().await;
-    let snap = mem_pool_state.load();
-    let state = snap.state().unwrap();
+    let state = mem_pool_state.load_state_db();
 
     let alice_id = state
         .get_account_id_by_script_hash(&alice_wallet.account_script_hash())
@@ -133,8 +132,7 @@ async fn test_block_max_cycles_limit() {
         .await
         .unwrap();
 
-    let snap = mem_pool_state.load();
-    let state = snap.state().unwrap();
+    let state = mem_pool_state.load_state_db();
 
     // We will submit two txs, expect bob's tx to be packaged in next block due to
     // block max cycles limit.
@@ -254,8 +252,7 @@ async fn test_block_max_cycles_limit() {
     };
 
     let mem_pool_state = chain.mem_pool_state().await;
-    let snap = mem_pool_state.load();
-    let state = snap.state().unwrap();
+    let state = mem_pool_state.load_state_db();
 
     let alice_nonce_before = state.get_nonce(alice_id);
     let available_cycles_before = {
@@ -296,8 +293,7 @@ async fn test_block_max_cycles_limit() {
     let not_in_queue = !rpc_server.is_request_in_queue(bob_tx_hash).await.unwrap();
     assert!(not_in_queue);
 
-    let snap = mem_pool_state.load();
-    let state = snap.state().unwrap();
+    let state = mem_pool_state.load_state_db();
 
     let alice_nonce_after = state.get_nonce(alice_id);
     let available_cycles_after = {
@@ -391,8 +387,7 @@ async fn test_block_max_cycles_limit() {
     };
 
     let mem_pool_state = chain.mem_pool_state().await;
-    let snap = mem_pool_state.load();
-    let state = snap.state().unwrap();
+    let state = mem_pool_state.load_state_db();
 
     let alice_nonce_before = state.get_nonce(alice_id);
 
@@ -429,8 +424,7 @@ async fn test_block_max_cycles_limit() {
     let not_in_queue = !rpc_server.is_request_in_queue(bob_tx_hash).await.unwrap();
     assert!(not_in_queue);
 
-    let snap = mem_pool_state.load();
-    let state = snap.state().unwrap();
+    let state = mem_pool_state.load_state_db();
 
     let alice_nonce_after = state.get_nonce(alice_id);
     assert_eq!(alice_nonce_before, alice_nonce_after);
diff --git a/crates/tests/src/tests/rpc_server/submit_withdrawal_request.rs b/crates/tests/src/tests/rpc_server/submit_withdrawal_request.rs
index d1626c138..d7a5f79ed 100644
--- a/crates/tests/src/tests/rpc_server/submit_withdrawal_request.rs
+++ b/crates/tests/src/tests/rpc_server/submit_withdrawal_request.rs
@@ -49,8 +49,7 @@ async fn test_submit_withdrawal_request() {
     }
 
     let mem_pool_state = chain.mem_pool_state().await;
-    let snap = mem_pool_state.load();
-    let state = snap.state().unwrap();
+    let state = mem_pool_state.load_state_db();
 
     let balance_before_withdrawal = state
         .get_sudt_balance(CKB_SUDT_ACCOUNT_ID, test_wallet.reg_address())
@@ -108,8 +107,7 @@ async fn test_submit_withdrawal_request() {
         .await
         .unwrap();
 
-    let snap = mem_pool_state.load();
-    let state = snap.state().unwrap();
+    let state = mem_pool_state.load_state_db();
     let balance_after_withdrawal = state
         .get_sudt_balance(CKB_SUDT_ACCOUNT_ID, test_wallet.reg_address())
         .unwrap();
diff --git a/crates/tx-filter/src/polyjuice_contract_creator_allowlist.rs b/crates/tx-filter/src/polyjuice_contract_creator_allowlist.rs
index c9ebb073c..c3941ff67 100644
--- a/crates/tx-filter/src/polyjuice_contract_creator_allowlist.rs
+++ b/crates/tx-filter/src/polyjuice_contract_creator_allowlist.rs
@@ -162,7 +162,7 @@ mod tests {
             self.tree.update(key, value)?;
             Ok(())
         }
-        fn calculate_root(&self) -> Result<H256, Error> {
+        fn finalise_root(&mut self) -> Result<H256, Error> {
             let root = *self.tree.root();
             Ok(root)
         }
diff --git a/crates/utils/src/export_block.rs b/crates/utils/src/export_block.rs
index 01c8919fe..8add8c194 100644
--- a/crates/utils/src/export_block.rs
+++ b/crates/utils/src/export_block.rs
@@ -3,8 +3,7 @@ use std::io::{ErrorKind, Read, Seek, SeekFrom};
 use anyhow::{anyhow, bail, Context, Result};
 use gw_common::{h256_ext::H256Ext, H256};
 use gw_store::{
-    readonly::StoreReadonly, state::state_db::StateContext, traits::chain_store::ChainStore,
-    transaction::StoreTransaction,
+    readonly::StoreReadonly, traits::chain_store::ChainStore, transaction::StoreTransaction,
 };
 use gw_types::{
     bytes::Bytes,
@@ -201,7 +200,7 @@ pub fn check_block_post_state(
 ) -> Result<()> {
     // Check account smt
     let expected_account_smt = post_global_state.account();
-    let replicate_account_smt = tx_db.state_tree(StateContext::ReadOnly)?.get_merkle_state();
+    let replicate_account_smt = tx_db.get_last_valid_tip_block()?.raw().post_account();
     if replicate_account_smt.as_slice() != expected_account_smt.as_slice() {
         bail!("replicate block {} account smt diff", block_number);
     }

From 9c32522cae138f4567941e602f23f120a7983217 Mon Sep 17 00:00:00 2001
From: jjy <jjyruby@gmail.com>
Date: Mon, 31 Oct 2022 17:44:19 +0800
Subject: [PATCH 02/10] fix: fix tests

---
 crates/tests/src/tests/deposit_withdrawal.rs | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/crates/tests/src/tests/deposit_withdrawal.rs b/crates/tests/src/tests/deposit_withdrawal.rs
index 4b12ee731..50275d90e 100644
--- a/crates/tests/src/tests/deposit_withdrawal.rs
+++ b/crates/tests/src/tests/deposit_withdrawal.rs
@@ -550,8 +550,7 @@ async fn test_produce_block_after_re_inject_withdrawal() {
     .unwrap();
     let (user_id, user_script_hash, user_addr, ckb_balance) = {
         let mem_pool = chain.mem_pool().as_ref().unwrap().lock().await;
-        let snap = mem_pool.mem_pool_state().load();
-        let tree = snap.state().unwrap();
+        let tree = mem_pool.mem_pool_state().load_state_db();
         // check user account
         assert_eq!(
             tree.get_account_count().unwrap(),
@@ -647,8 +646,8 @@ async fn test_produce_block_after_re_inject_withdrawal() {
 
     // check status
 
-    let db = chain.store().begin_transaction();
-    let tree = db.state_tree(StateContext::ReadOnly).unwrap();
+    let db = &chain.store().begin_transaction();
+    let tree = BlockStateDB::from_store(db, RWConfig::readonly()).unwrap();
     let ckb_balance2 = tree
         .get_sudt_balance(CKB_SUDT_ACCOUNT_ID, &user_addr)
         .unwrap();

From 2d6a7a8972f8b527825406cbf897fd8b7177999c Mon Sep 17 00:00:00 2001
From: jjy <jjyruby@gmail.com>
Date: Tue, 1 Nov 2022 17:42:28 +0800
Subject: [PATCH 03/10] refactor: refactor L2Syscalls

---
 Cargo.lock                                    |   1 +
 .../benches/benches/benchmarks/dummy_state.rs |   5 +-
 crates/block-producer/src/replay_block.rs     |   9 +-
 crates/chain/src/chain.rs                     |  12 +-
 crates/challenge/src/offchain.rs              |   8 +-
 crates/challenge/src/offchain/mock_block.rs   |  23 +-
 crates/common/src/state.rs                    |   7 +-
 crates/generator/src/error.rs                 |   6 +-
 crates/generator/src/generator.rs             | 356 ++++++++--------
 crates/generator/src/genesis.rs               |   9 +-
 crates/generator/src/syscalls/mod.rs          | 172 ++++----
 crates/generator/src/tests/dummy_state.rs     | 398 ++++++++----------
 crates/generator/src/traits.rs                |  52 +--
 crates/generator/src/types/mod.rs             |   1 -
 .../generator/src/types/run_result_state.rs   |  48 ---
 crates/jsonrpc-types/src/godwoken.rs          |   4 +-
 crates/mem-pool/src/pool.rs                   |  49 ++-
 crates/polyjuice-sender-recover/Cargo.toml    |   1 +
 .../src/mem_execute_tx_state.rs               |  98 +----
 .../src/recover/eth_recover.rs                |  15 +-
 crates/rpc-server/src/registry.rs             |  23 +-
 .../store/src/state/history/history_state.rs  |   2 +-
 crates/store/src/state/overlay/mem_state.rs   |  13 +-
 crates/store/src/state/state_db.rs            | 161 ++++---
 crates/store/src/state/traits.rs              |  14 +
 crates/store/src/tests/state_db.rs            |   9 +-
 crates/tests/src/tests/chain.rs               |  12 +-
 crates/tests/src/tests/mem_block_repackage.rs |   4 +-
 .../tx-filter/src/erc20_creator_allowlist.rs  |   6 +-
 .../polyjuice_contract_creator_allowlist.rs   |   2 +-
 crates/types/src/offchain/extension.rs        |   5 +-
 crates/types/src/offchain/generator.rs        |  11 +
 crates/types/src/offchain/mod.rs              |   2 +
 crates/types/src/offchain/run_result.rs       |  31 +-
 34 files changed, 704 insertions(+), 865 deletions(-)
 delete mode 100644 crates/generator/src/types/run_result_state.rs
 create mode 100644 crates/types/src/offchain/generator.rs

diff --git a/Cargo.lock b/Cargo.lock
index af7468ed9..95c065cde 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1892,6 +1892,7 @@ dependencies = [
  "anyhow",
  "gw-common",
  "gw-generator",
+ "gw-store",
  "gw-traits",
  "gw-types",
  "gw-utils",
diff --git a/crates/benches/benches/benchmarks/dummy_state.rs b/crates/benches/benches/benchmarks/dummy_state.rs
index 229621638..902bb9ee2 100644
--- a/crates/benches/benches/benchmarks/dummy_state.rs
+++ b/crates/benches/benches/benchmarks/dummy_state.rs
@@ -24,7 +24,10 @@ impl State for DummyState {
         self.tree.update(key, value)?;
         Ok(())
     }
-    fn finalise_root(&mut self) -> Result<H256, Error> {
+    fn finalise(&mut self) -> Result<(), Error> {
+        Err(Error::Store)
+    }
+    fn calculate_root(&self) -> Result<H256, Error> {
         let root = *self.tree.root();
         Ok(root)
     }
diff --git a/crates/block-producer/src/replay_block.rs b/crates/block-producer/src/replay_block.rs
index 6bbf929c2..0fea89aa6 100644
--- a/crates/block-producer/src/replay_block.rs
+++ b/crates/block-producer/src/replay_block.rs
@@ -8,6 +8,7 @@ use gw_generator::constants::L2TX_MAX_CYCLES;
 use gw_generator::traits::StateExt;
 use gw_generator::Generator;
 use gw_store::chain_view::ChainView;
+use gw_store::state::traits::JournalDB;
 use gw_store::state::MemStateDB;
 use gw_store::traits::chain_store::ChainStore;
 use gw_store::Store;
@@ -40,7 +41,7 @@ impl ReplayBlock {
             let parent_post_state = parent_block.raw().post_account();
             assert_eq!(
                 parent_post_state,
-                state.finalise_merkle_state()?,
+                state.calculate_merkle_state()?,
                 "merkle state should equals to parent block"
             );
         };
@@ -107,16 +108,16 @@ impl ReplayBlock {
 
             // build call context
             // NOTICE users only allowed to send HandleMessage CallType txs
-            let run_result = generator.execute_transaction(
+            generator.execute_transaction(
                 &chain_view,
-                &state,
+                &mut state,
                 &block_info,
                 &raw_tx,
                 L2TX_MAX_CYCLES,
                 None,
             )?;
 
-            state.apply_run_result(&run_result.write)?;
+            state.finalise()?;
             let expected_checkpoint = state.calculate_state_checkpoint()?;
             let checkpoint_index = withdrawals.len() + tx_index;
             let block_checkpoint: H256 = match state_checkpoint_list.get(checkpoint_index) {
diff --git a/crates/chain/src/chain.rs b/crates/chain/src/chain.rs
index 6be974873..b70896a91 100644
--- a/crates/chain/src/chain.rs
+++ b/crates/chain/src/chain.rs
@@ -729,10 +729,10 @@ impl Chain {
 
                     // Check current state
                     let expected_state = l2block.raw().prev_account();
-                    let mut tree = BlockStateDB::from_store(db, RWConfig::readonly())?;
+                    let tree = BlockStateDB::from_store(db, RWConfig::readonly())?;
                     let expected_root: H256 = expected_state.merkle_root().unpack();
                     let expected_count: u32 = expected_state.count().unpack();
-                    assert_eq!(tree.finalise_root()?, expected_root);
+                    assert_eq!(tree.calculate_root()?, expected_root);
                     assert_eq!(tree.get_account_count()?, expected_count);
 
                     // Check genesis state still consistent
@@ -896,8 +896,8 @@ impl Chain {
             "account root consistent in DB"
         );
 
-        let mut tree = BlockStateDB::from_store(db, RWConfig::readonly())?;
-        let current_account = tree.finalise_merkle_state()?;
+        let tree = BlockStateDB::from_store(db, RWConfig::readonly())?;
+        let current_account = tree.calculate_merkle_state()?;
 
         assert_eq!(
             current_account.as_slice(),
@@ -1001,11 +1001,11 @@ impl Chain {
         let chain_view = ChainView::new(&db, tip_block_hash);
 
         {
-            let mut tree = BlockStateDB::from_store(db, RWConfig::readonly())?;
+            let tree = BlockStateDB::from_store(db, RWConfig::readonly())?;
 
             let prev_merkle_state = l2block.raw().prev_account();
             assert_eq!(
-                tree.finalise_merkle_state()?.as_slice(),
+                tree.calculate_merkle_state()?.as_slice(),
                 prev_merkle_state.as_slice(),
                 "prev account merkle state must be consistent"
             );
diff --git a/crates/challenge/src/offchain.rs b/crates/challenge/src/offchain.rs
index 03768df42..c9c754b79 100644
--- a/crates/challenge/src/offchain.rs
+++ b/crates/challenge/src/offchain.rs
@@ -1,7 +1,5 @@
 #![allow(clippy::mutable_key_type)]
 
-use crate::cancel_challenge::LoadDataStrategy;
-
 use anyhow::{anyhow, bail, Result};
 use ckb_chain_spec::consensus::MAX_BLOCK_BYTES;
 use gw_common::registry_address::RegistryAddress;
@@ -12,9 +10,9 @@ use gw_rpc_client::rpc_client::RPCClient;
 use gw_store::state::MemStateDB;
 use gw_store::transaction::StoreTransaction;
 use gw_types::core::DepType;
-use gw_types::offchain::{CellInfo, InputCellInfo, RollupContext, RunResult};
+use gw_types::offchain::{CellInfo, InputCellInfo, RollupContext};
 use gw_types::packed::{
-    CellDep, CellInput, L2Block, L2Transaction, OutPoint, OutPointVec, WithdrawalRequestExtra,
+    CellDep, CellInput, L2Block, OutPoint, OutPointVec, WithdrawalRequestExtra,
 };
 use gw_types::prelude::{Builder, Entity, Unpack};
 use gw_utils::wallet::Wallet;
@@ -314,6 +312,7 @@ impl OffChainCancelChallengeValidator {
         self.block_param.set_prev_txs_checkpoint(checkpoint)
     }
 
+    #[cfg(gw_challenge)]
     pub fn verify_transaction(
         &mut self,
         db: &StoreTransaction,
@@ -502,6 +501,7 @@ struct MarginOfMockBlockSafity {
     prev_raw_block_size: u64,
 }
 
+#[allow(dead_code)]
 #[derive(Clone, Copy, PartialEq, Eq)]
 enum RawBlockFlag {
     New,
diff --git a/crates/challenge/src/offchain/mock_block.rs b/crates/challenge/src/offchain/mock_block.rs
index 189b8d8f4..edabc7302 100644
--- a/crates/challenge/src/offchain/mock_block.rs
+++ b/crates/challenge/src/offchain/mock_block.rs
@@ -1,7 +1,6 @@
 use crate::types::{VerifyContext, VerifyWitness};
 
 use anyhow::{anyhow, bail, Context, Result};
-use gw_common::blake2b::new_blake2b;
 use gw_common::h256_ext::H256Ext;
 use gw_common::merkle_utils::{
     calculate_ckb_merkle_root, calculate_state_checkpoint, ckb_merkle_leaf_hash, CBMT,
@@ -14,21 +13,19 @@ use gw_common::state::{
 };
 use gw_common::H256;
 use gw_generator::traits::StateExt;
+use gw_store::state::traits::JournalDB;
 use gw_store::state::MemStateDB;
 use gw_store::transaction::StoreTransaction;
 use gw_traits::CodeStore;
 use gw_types::core::{ChallengeTargetType, Status};
 use gw_types::offchain::{RollupContext, RunResult};
 use gw_types::packed::{
-    AccountMerkleState, BlockMerkleState, Byte32, Bytes, CCTransactionSignatureWitness,
-    CCTransactionWitness, CCWithdrawalWitness, CKBMerkleProof, ChallengeTarget, GlobalState,
-    L2Block, L2Transaction, RawL2Block, Script, ScriptVec, SubmitTransactions, SubmitWithdrawals,
-    Uint64, WithdrawalRequestExtra,
+    AccountMerkleState, BlockMerkleState, Byte32, CCTransactionSignatureWitness,
+    CCWithdrawalWitness, CKBMerkleProof, ChallengeTarget, GlobalState, L2Block, L2Transaction,
+    RawL2Block, Script, SubmitTransactions, SubmitWithdrawals, Uint64, WithdrawalRequestExtra,
 };
 use gw_types::prelude::*;
 
-use std::collections::HashMap;
-
 type MemTree = MemStateDB;
 
 #[derive(thiserror::Error, Debug)]
@@ -110,7 +107,7 @@ impl MockBlockParam {
             &self.block_producer,
             &req.request(),
         )?;
-        let post_account = mem_tree.finalise_merkle_state()?;
+        let post_account = mem_tree.calculate_merkle_state()?;
         let checkpoint = calculate_state_checkpoint(
             &post_account.merkle_root().unpack(),
             post_account.count().unpack(),
@@ -131,7 +128,7 @@ impl MockBlockParam {
         &mut self,
         mem_tree: &mut MemTree,
         tx: L2Transaction,
-        run_result: &RunResult,
+        _run_result: &RunResult,
     ) -> Result<()> {
         if self.transactions.contains(&tx) {
             bail!("duplicate transaction {}", tx.hash().pack());
@@ -139,7 +136,7 @@ impl MockBlockParam {
 
         if self.transactions.inner.is_empty() {
             let checkpoint = {
-                let prev_txs_state = mem_tree.finalise_merkle_state()?;
+                let prev_txs_state = mem_tree.calculate_merkle_state()?;
                 calculate_state_checkpoint(
                     &prev_txs_state.merkle_root().unpack(),
                     prev_txs_state.count().unpack(),
@@ -149,8 +146,8 @@ impl MockBlockParam {
             self.transactions.set_prev_txs_checkpoint(checkpoint);
         }
 
-        mem_tree.apply_run_result(&run_result.write)?;
-        let post_account = mem_tree.finalise_merkle_state()?;
+        mem_tree.finalise()?;
+        let post_account = mem_tree.calculate_merkle_state()?;
         let checkpoint = calculate_state_checkpoint(
             &post_account.merkle_root().unpack(),
             post_account.count().unpack(),
@@ -243,6 +240,7 @@ impl MockBlockParam {
         })
     }
 
+    #[cfg(gw_challenge)]
     pub fn challenge_last_tx_execution(
         &self,
         db: &StoreTransaction,
@@ -436,6 +434,7 @@ impl MockBlockParam {
         })
     }
 
+    #[cfg(gw_challenge)]
     fn build_transaction_execution_verify_context(
         &self,
         mem_tree: &mut MemTree,
diff --git a/crates/common/src/state.rs b/crates/common/src/state.rs
index 18910d6cb..82ce0b0b7 100644
--- a/crates/common/src/state.rs
+++ b/crates/common/src/state.rs
@@ -131,8 +131,7 @@ pub trait State {
     fn update_raw(&mut self, key: H256, value: H256) -> Result<(), Error>;
     fn get_account_count(&self) -> Result<u32, Error>;
     fn set_account_count(&mut self, count: u32) -> Result<(), Error>;
-    // Refresh dirty state and return current root
-    fn finalise_root(&mut self) -> Result<H256, Error>;
+    fn calculate_root(&self) -> Result<H256, Error>;
 
     // implementations
     fn get_value(&self, id: u32, key: &[u8]) -> Result<H256, Error> {
@@ -278,8 +277,8 @@ pub trait State {
     }
 
     /// calculate state checkpoint
-    fn calculate_state_checkpoint(&mut self) -> Result<H256, Error> {
-        let account_root = self.finalise_root()?;
+    fn calculate_state_checkpoint(&self) -> Result<H256, Error> {
+        let account_root = self.calculate_root()?;
         let account_count = self.get_account_count()?;
         Ok(calculate_state_checkpoint(&account_root, account_count))
     }
diff --git a/crates/generator/src/error.rs b/crates/generator/src/error.rs
index 8c9f66643..da2c0da50 100644
--- a/crates/generator/src/error.rs
+++ b/crates/generator/src/error.rs
@@ -2,7 +2,7 @@ use std::borrow::Cow;
 
 use ckb_vm::Error as VMError;
 use gw_common::{error::Error as StateError, sparse_merkle_tree::error::Error as SMTError, H256};
-use gw_types::{offchain::RunResultCycles, packed::Byte32};
+use gw_types::{offchain::CycleMeter, packed::Byte32};
 use thiserror::Error;
 
 /// Error
@@ -160,9 +160,9 @@ pub enum TransactionError {
     #[error("Intrinsic gas: {0}")]
     IntrinsicGas(Cow<'static, str>),
     #[error("Insufficient pool cycles: cycles {cycles:?}, limit {limit}")]
-    InsufficientPoolCycles { cycles: RunResultCycles, limit: u64 },
+    InsufficientPoolCycles { cycles: CycleMeter, limit: u64 },
     #[error("Exceeded max block cycles: cycles {cycles:?}, limit {limit}")]
-    ExceededMaxBlockCycles { cycles: RunResultCycles, limit: u64 },
+    ExceededMaxBlockCycles { cycles: CycleMeter, limit: u64 },
     #[error("Convert to UTF-8 error: {0}")]
     Utf8Error(std::str::Utf8Error),
     #[error("Native token transfer error, invalid to_id: {0}")]
diff --git a/crates/generator/src/generator.rs b/crates/generator/src/generator.rs
index 16ff7c42a..c3a7d1232 100644
--- a/crates/generator/src/generator.rs
+++ b/crates/generator/src/generator.rs
@@ -9,7 +9,7 @@ use crate::{
     backend_manage::BackendManage,
     constants::{L2TX_MAX_CYCLES, MAX_READ_DATA_BYTES_LIMIT, MAX_WRITE_DATA_BYTES_LIMIT},
     error::{BlockError, TransactionValidateError, WithdrawalError},
-    run_result_state::RunResultState,
+    syscalls::RunContext,
     typed_transaction::types::TypedRawTransaction,
     types::vm::VMVersion,
     utils::{get_polyjuice_creator_id, get_tx_type},
@@ -26,28 +26,25 @@ use gw_ckb_hardfork::GLOBAL_VM_VERSION;
 use gw_common::{
     builtins::{CKB_SUDT_ACCOUNT_ID, ETH_REGISTRY_ACCOUNT_ID},
     error::Error as StateError,
-    h256_ext::H256Ext,
     registry_address::RegistryAddress,
-    state::{
-        build_account_field_key, build_account_key, build_sudt_key, State, GW_ACCOUNT_NONCE_TYPE,
-        SUDT_KEY_FLAG_BALANCE, SUDT_TOTAL_SUPPLY_KEY,
-    },
+    state::State,
     H256,
 };
 
 use gw_config::{ContractLogConfig, SyscallCyclesConfig};
 use gw_store::{
-    state::{history::history_state::RWConfig, BlockStateDB},
+    state::{history::history_state::RWConfig, traits::JournalDB, BlockStateDB},
     transaction::StoreTransaction,
 };
 use gw_traits::{ChainView, CodeStore};
 use gw_types::{
     bytes::Bytes,
     core::{ChallengeTargetType, ScriptHashType},
-    offchain::{RollupContext, RunResult, RunResultCycles},
+    offchain::{CycleMeter, RollupContext, RunResult},
     packed::{
         AccountMerkleState, BlockInfo, ChallengeTarget, DepositInfoVec, L2Block, L2Transaction,
-        RawL2Block, RawL2Transaction, TxReceipt, WithdrawalReceipt, WithdrawalRequestExtra,
+        LogItem, RawL2Block, RawL2Transaction, TxReceipt, WithdrawalReceipt,
+        WithdrawalRequestExtra,
     },
     prelude::*,
 };
@@ -142,7 +139,7 @@ impl CyclesPool {
 
 pub struct MachineRunArgs<'a, C, S> {
     chain: &'a C,
-    state: &'a S,
+    state: &'a mut S,
     block_info: &'a BlockInfo,
     raw_tx: &'a RawL2Transaction,
     max_cycles: u64,
@@ -183,10 +180,10 @@ impl Generator {
     }
 
     #[instrument(skip_all, fields(backend = ?args.backend.backend_type))]
-    fn machine_run<S: State + CodeStore, C: ChainView>(
+    fn machine_run<S: State + CodeStore + JournalDB, C: ChainView>(
         &self,
         args: MachineRunArgs<'_, C, S>,
-    ) -> Result<RunResult, TransactionError> {
+    ) -> Result<RunContext, TransactionError> {
         const INVALID_CYCLES_EXIT_CODE: i8 = -1;
 
         let MachineRunArgs {
@@ -199,7 +196,7 @@ impl Generator {
             mut cycles_pool,
         } = args;
 
-        let mut run_result = RunResult::default();
+        let mut context = RunContext::default();
         let used_cycles;
         let exit_code;
         let org_cycles_pool = cycles_pool.as_mut().map(|p| p.clone());
@@ -221,10 +218,9 @@ impl Generator {
                     raw_tx,
                     rollup_context: &self.rollup_context,
                     account_lock_manage: &self.account_lock_manage,
-                    result: &mut run_result,
-                    code_store: state,
                     cycles_pool: &mut cycles_pool,
                     log_buf: &mut sys_log_buf,
+                    context: &mut context,
                 }))
                 .instruction_cycle_func(Box::new(instruction_cycles));
             let default_machine = machine_builder.build();
@@ -252,9 +248,9 @@ impl Generator {
             // Subtract tx execution cycles.
             if let Some(cycles_pool) = &mut cycles_pool {
                 if cycles_pool.consume_cycles(execution_cycles).is_none() {
-                    let cycles = RunResultCycles {
+                    let cycles = CycleMeter {
                         execution: execution_cycles,
-                        r#virtual: run_result.cycles.r#virtual,
+                        r#virtual: context.cycle_meter.r#virtual,
                     };
                     let limit = cycles_pool.limit;
 
@@ -300,10 +296,10 @@ impl Generator {
                 used_cycles
             );
         }
-        run_result.cycles.execution = used_cycles;
-        run_result.exit_code = exit_code;
+        context.cycle_meter.execution = used_cycles;
+        context.exit_code = exit_code;
 
-        Ok(run_result)
+        Ok(context)
     }
 
     /// Check withdrawal request signature
@@ -492,7 +488,11 @@ impl Generator {
             }
         }
 
-        let prev_txs_state = match state.finalise_merkle_state() {
+        // finalise state
+        if let Err(err) = state.finalise() {
+            return ApplyBlockResult::Error(err.into());
+        }
+        let prev_txs_state = match state.calculate_merkle_state() {
             Ok(s) => s,
             Err(err) => {
                 return ApplyBlockResult::Error(err);
@@ -560,7 +560,7 @@ impl Generator {
             // skip whitelist validate since we are validating a committed block
             let run_result = match self.execute_transaction(
                 chain,
-                &state,
+                &mut state,
                 &block_info,
                 &raw_tx,
                 L2TX_MAX_CYCLES,
@@ -584,8 +584,9 @@ impl Generator {
 
             {
                 let now = Instant::now();
-                if let Err(err) = state.apply_run_result(&run_result.write) {
-                    return ApplyBlockResult::Error(err);
+                // finalise tx state
+                if let Err(err) = state.finalise() {
+                    return ApplyBlockResult::Error(err.into());
                 }
                 apply_state_total_ms += now.elapsed().as_millis();
                 let expected_checkpoint = state
@@ -621,7 +622,7 @@ impl Generator {
                 }
 
                 let used_cycles = run_result.cycles.execution;
-                let post_state = match state.finalise_merkle_state() {
+                let post_state = match state.calculate_merkle_state() {
                     Ok(merkle_state) => merkle_state,
                     Err(err) => return ApplyBlockResult::Error(err),
                 };
@@ -638,7 +639,7 @@ impl Generator {
             let post_merkle_root: H256 = raw_block.post_account().merkle_root().unpack();
             let post_merkle_count: u32 = raw_block.post_account().count().unpack();
             assert_eq!(
-                state.finalise_root().expect("check post root"),
+                state.calculate_root().expect("check post root"),
                 post_merkle_root,
                 "post account merkle root must be consistent"
             );
@@ -697,10 +698,10 @@ impl Generator {
 
     /// execute a layer2 tx
     #[instrument(skip_all)]
-    pub fn execute_transaction<S: State + CodeStore, C: ChainView>(
+    pub fn execute_transaction<S: State + CodeStore + JournalDB, C: ChainView>(
         &self,
         chain: &C,
-        state: &S,
+        state: &mut S,
         block_info: &BlockInfo,
         raw_tx: &RawL2Transaction,
         max_cycles: u64,
@@ -719,10 +720,10 @@ impl Generator {
 
     /// execute a layer2 tx, doesn't check exit code
     #[instrument(skip_all, fields(block = block_info.number().unpack(), tx_hash = %raw_tx.hash().pack()))]
-    pub fn unchecked_execute_transaction<S: State + CodeStore, C: ChainView>(
+    pub fn unchecked_execute_transaction<S: State + CodeStore + JournalDB, C: ChainView>(
         &self,
         chain: &C,
-        state: &S,
+        state: &mut S,
         block_info: &BlockInfo,
         raw_tx: &RawL2Transaction,
         max_cycles: u64,
@@ -734,6 +735,11 @@ impl Generator {
             .load_backend(block_info.number().unpack(), state, &script_hash)
             .ok_or(TransactionError::BackendNotFound { script_hash })?;
 
+        let snap = state.snapshot();
+        let sender_id: u32 = raw_tx.from_id().unpack();
+        let nonce_before = state.get_nonce(sender_id)?;
+        state.set_state_tracker(Default::default());
+
         let args = MachineRunArgs {
             chain,
             state,
@@ -744,8 +750,79 @@ impl Generator {
             cycles_pool,
         };
 
-        let run_result: RunResult = self.machine_run(args)?;
-        self.handle_run_result(state, block_info, raw_tx, run_result)
+        let run_context = self.machine_run(args).map_err(|err| {
+            state.revert(snap).expect("revert");
+            err
+        })?;
+
+        if run_context.is_success() {
+            // check sender's nonce is increased by backends
+            let nonce_after = state.get_nonce(sender_id)?;
+            if nonce_after <= nonce_before {
+                log::error!(
+                    "nonce should increased by backends nonce before: {}, nonce after: {}",
+                    nonce_before,
+                    nonce_after
+                );
+                return Err(TransactionError::BackendMustIncreaseNonce);
+            }
+        } else {
+            // handle failure state, this function will revert to snapshot
+            self.handle_failed_transaction(state, snap, nonce_before, block_info, raw_tx)?;
+        }
+
+        let state_tracker = state.take_state_tracker().unwrap();
+
+        // check write data bytes
+        if let Some(data) = state_tracker
+            .write_data()
+            .lock()
+            .unwrap()
+            .values()
+            .find(|data| data.len() > MAX_WRITE_DATA_BYTES_LIMIT)
+        {
+            return Err(TransactionError::ExceededMaxWriteData {
+                max_bytes: MAX_WRITE_DATA_BYTES_LIMIT,
+                used_bytes: data.len(),
+            });
+        }
+        // check read data bytes
+        let read_data_bytes: usize = state_tracker
+            .read_data()
+            .lock()
+            .unwrap()
+            .values()
+            .map(Bytes::len)
+            .sum();
+        if read_data_bytes > MAX_READ_DATA_BYTES_LIMIT {
+            return Err(TransactionError::ExceededMaxReadData {
+                max_bytes: MAX_READ_DATA_BYTES_LIMIT,
+                used_bytes: read_data_bytes,
+            });
+        }
+        let r = RunResult {
+            return_data: run_context.return_data,
+            logs: state.appended_logs().into_iter().cloned().collect(),
+            exit_code: run_context.exit_code,
+            cycles: run_context.cycle_meter,
+            read_data_hashes: state_tracker
+                .read_data()
+                .lock()
+                .unwrap()
+                .keys()
+                .into_iter()
+                .cloned()
+                .collect(),
+            write_data_hashes: state_tracker
+                .write_data()
+                .lock()
+                .unwrap()
+                .keys()
+                .into_iter()
+                .cloned()
+                .collect(),
+        };
+        Ok(r)
     }
 
     pub fn backend_manage(&self) -> &BackendManage {
@@ -765,164 +842,100 @@ impl Generator {
         Ok(self.polyjuice_creator_id.load_full().map(|id| *id))
     }
 
-    // check and handle run_result before return
-    fn handle_run_result<S: State + CodeStore>(
+    // Handle failed transaction
+    fn handle_failed_transaction<S: State + CodeStore + JournalDB>(
         &self,
-        state: &S,
+        state: &mut S,
+        origin_snapshot: usize,
+        nonce_before: u32,
         block_info: &BlockInfo,
         raw_tx: &RawL2Transaction,
-        mut run_result: RunResult,
-    ) -> Result<RunResult, TransactionError> {
+    ) -> Result<(), TransactionError> {
         /// Error code represents EVM internal error
         /// we emit this error from Godwoken side if
         /// Polyjuice failed to generate a system log
         const ERROR_EVM_INTERNAL: i32 = -1;
 
         let sender_id: u32 = raw_tx.from_id().unpack();
-        let nonce_raw_key = build_account_field_key(sender_id, GW_ACCOUNT_NONCE_TYPE);
-        let nonce_before = state.get_nonce(sender_id)?;
-
-        if 0 == run_result.exit_code {
-            // check sender's nonce is increased by backends
-            let nonce_after = {
-                let value = run_result
-                    .write
-                    .write_values
-                    .get(&nonce_raw_key)
-                    .ok_or(TransactionError::BackendMustIncreaseNonce)?;
-                value.to_u32()
-            };
-            if nonce_after <= nonce_before {
-                log::error!(
-                    "nonce should increased by backends nonce before: {}, nonce after: {}",
-                    nonce_before,
-                    nonce_after
-                );
-                return Err(TransactionError::BackendMustIncreaseNonce);
-            }
-        } else {
-            // revert tx
-            let last_run_result_log = run_result.write.logs.pop();
-            run_result.revert_write();
-
-            // sender address
-            let payer = {
-                let script_hash = state.get_script_hash(sender_id)?;
-                state
-                    .get_registry_address_by_script_hash(ETH_REGISTRY_ACCOUNT_ID, &script_hash)?
-                    .ok_or(TransactionError::ScriptHashNotFound)?
-            };
 
-            // block producer address
-            let block_producer =
-                RegistryAddress::from_slice(&block_info.block_producer().raw_data())
-                    .unwrap_or_default();
+        // revert tx state
+        let last_run_result_log = state.appended_logs().last().cloned();
+        state.revert(origin_snapshot)?;
 
-            // add charging fee key-values into run result
-            {
-                let sender_sudt_key = {
-                    let sudt_key = build_sudt_key(SUDT_KEY_FLAG_BALANCE, &payer);
-                    build_account_key(CKB_SUDT_ACCOUNT_ID, &sudt_key)
-                };
-                let block_producer_sudt_key = {
-                    let sudt_key = build_sudt_key(SUDT_KEY_FLAG_BALANCE, &block_producer);
-                    build_account_key(CKB_SUDT_ACCOUNT_ID, &sudt_key)
-                };
-                let total_supply_key =
-                    build_account_key(CKB_SUDT_ACCOUNT_ID, &SUDT_TOTAL_SUPPLY_KEY);
-                for raw_key in [sender_sudt_key, block_producer_sudt_key, total_supply_key] {
-                    let raw_value = state.get_raw(&raw_key)?;
-                    run_result.read_values.entry(raw_key).or_insert(raw_value);
-                }
-            }
+        // sender address
+        let payer = {
+            let script_hash = state.get_script_hash(sender_id)?;
+            state
+                .get_registry_address_by_script_hash(ETH_REGISTRY_ACCOUNT_ID, &script_hash)?
+                .ok_or(TransactionError::ScriptHashNotFound)?
+        };
 
-            // handle tx fee
-            let tx_type = get_tx_type(self.rollup_context(), state, raw_tx)?;
-            let typed_tx = TypedRawTransaction::from_tx(raw_tx.to_owned(), tx_type)
-                .expect("Unknown type of tx");
-            let tx_fee = match typed_tx {
-                TypedRawTransaction::EthAddrReg(tx) => tx.consumed(),
-                TypedRawTransaction::Meta(tx) => tx.consumed(),
-                TypedRawTransaction::SimpleUDT(tx) => tx.consumed(),
-                TypedRawTransaction::Polyjuice(ref tx) => {
-                    // push polyjuice system log back to run_result
-                    if let Some(log) = last_run_result_log
-                        .filter(|log| log.service_flag() == GW_LOG_POLYJUICE_SYSTEM.into())
-                    {
-                        run_result.write.logs.push(log);
-                    } else {
+        // block producer address
+        let block_producer = RegistryAddress::from_slice(&block_info.block_producer().raw_data())
+            .unwrap_or_default();
+
+        // handle tx fee
+        let tx_type = get_tx_type(self.rollup_context(), state, raw_tx)?;
+        let typed_tx =
+            TypedRawTransaction::from_tx(raw_tx.to_owned(), tx_type).expect("Unknown type of tx");
+        let tx_fee = match typed_tx {
+            TypedRawTransaction::EthAddrReg(tx) => tx.consumed(),
+            TypedRawTransaction::Meta(tx) => tx.consumed(),
+            TypedRawTransaction::SimpleUDT(tx) => tx.consumed(),
+            TypedRawTransaction::Polyjuice(ref tx) => {
+                // push polyjuice system log back to run_result
+                let system_log = last_run_result_log
+                    .filter(|log| log.service_flag() == GW_LOG_POLYJUICE_SYSTEM.into())
+                    .map(Result::<_, TransactionError>::Ok)
+                    .unwrap_or_else(|| {
                         // generate a system log for polyjuice tx
                         let polyjuice_tx =
                             crate::typed_transaction::types::PolyjuiceTx::new(raw_tx.to_owned());
                         let p = polyjuice_tx.parser().ok_or(TransactionError::NoCost)?;
                         let gas = p.gas();
-                        run_result.write.logs.push(generate_polyjuice_system_log(
+                        Ok(generate_polyjuice_system_log(
                             raw_tx.to_id().unpack(),
                             gas,
                             gas,
                             Default::default(),
                             ERROR_EVM_INTERNAL,
-                        ));
+                        ))
+                    })?;
+                let parser = tx.parser().ok_or(TransactionError::NoCost)?;
+                let gas_used = match read_polyjuice_gas_used(&system_log) {
+                    Some(gas_used) => gas_used,
+                    None => {
+                        log::warn!(
+                            "[gw-generator] failed to parse gas_used, use gas_limit instead"
+                        );
+                        parser.gas()
                     }
-                    let parser = tx.parser().ok_or(TransactionError::NoCost)?;
-                    let gas_used = match read_polyjuice_gas_used(&run_result) {
-                        Some(gas_used) => gas_used,
-                        None => {
-                            log::warn!(
-                                "[gw-generator] failed to parse gas_used, use gas_limit instead"
-                            );
-                            parser.gas()
-                        }
-                    };
-                    gw_types::U256::from(gas_used).checked_mul(parser.gas_price().into())
-                }
+                };
+                // append system log
+                state.append_log(system_log);
+                gw_types::U256::from(gas_used).checked_mul(parser.gas_price().into())
             }
-            .ok_or(TransactionError::NoCost)?;
-
-            let mut run_result_state = RunResultState(&mut run_result);
-
-            run_result_state
-                .pay_fee(&payer, &block_producer, CKB_SUDT_ACCOUNT_ID, tx_fee)
-                .map_err(|err| {
-                    log::error!(
-                        "[gw-generator] failed to pay fee for failure tx, err: {}",
-                        err
-                    );
-                    TransactionError::InsufficientBalance
-                })?;
-
-            // increase sender's nonce
-            let nonce = nonce_before
-                .checked_add(1)
-                .ok_or(TransactionError::NonceOverflow)?;
-            run_result
-                .write
-                .write_values
-                .insert(nonce_raw_key, H256::from_u32(nonce));
         }
+        .ok_or(TransactionError::NoCost)?;
 
-        // check write data bytes
-        if let Some(data) = run_result
-            .write
-            .write_data
-            .values()
-            .find(|data| data.len() > MAX_WRITE_DATA_BYTES_LIMIT)
-        {
-            return Err(TransactionError::ExceededMaxWriteData {
-                max_bytes: MAX_WRITE_DATA_BYTES_LIMIT,
-                used_bytes: data.len(),
-            });
-        }
-        // check read data bytes
-        let read_data_bytes: usize = run_result.read_data.values().map(Bytes::len).sum();
-        if read_data_bytes > MAX_READ_DATA_BYTES_LIMIT {
-            return Err(TransactionError::ExceededMaxReadData {
-                max_bytes: MAX_READ_DATA_BYTES_LIMIT,
-                used_bytes: read_data_bytes,
-            });
-        }
+        // pay tx fee
+        state
+            .pay_fee(&payer, &block_producer, CKB_SUDT_ACCOUNT_ID, tx_fee)
+            .map_err(|err| {
+                log::error!(
+                    "[gw-generator] failed to pay fee for failure tx, err: {}",
+                    err
+                );
+                TransactionError::InsufficientBalance
+            })?;
 
-        Ok(run_result)
+        // increase sender's nonce
+        let nonce = nonce_before
+            .checked_add(1)
+            .ok_or(TransactionError::NonceOverflow)?;
+        state.set_nonce(sender_id, nonce)?;
+
+        Ok(())
     }
 }
 
@@ -947,16 +960,10 @@ fn build_challenge_target(
         .build()
 }
 
-fn read_polyjuice_gas_used(run_result: &RunResult) -> Option<u64> {
+fn read_polyjuice_gas_used(system_log: &LogItem) -> Option<u64> {
     // read polyjuice system log
-    match run_result
-        .write
-        .logs
-        .iter()
-        .find(|item| u8::from(item.service_flag()) == gw_utils::script_log::GW_LOG_POLYJUICE_SYSTEM)
-        .map(gw_utils::script_log::parse_log)
-    {
-        Some(Ok(polyjuice_system_log)) => {
+    match gw_utils::script_log::parse_log(system_log) {
+        Ok(polyjuice_system_log) => {
             if let gw_utils::script_log::GwLog::PolyjuiceSystem { gas_used, .. } =
                 polyjuice_system_log
             {
@@ -967,12 +974,9 @@ fn read_polyjuice_gas_used(run_result: &RunResult) -> Option<u64> {
                 )
             }
         }
-        Some(Err(err)) => {
+        Err(err) => {
             log::warn!("[gw-generator] read_polyjuice_gas_used: an error happend when parsing polyjuice system log, {}", err);
         }
-        None => {
-            log::warn!("[gw-generator] read_polyjuice_gas_used: Can't find polyjuice system log");
-        }
     }
     None
 }
diff --git a/crates/generator/src/genesis.rs b/crates/generator/src/genesis.rs
index 94cf0c9eb..fe4f01577 100644
--- a/crates/generator/src/genesis.rs
+++ b/crates/generator/src/genesis.rs
@@ -1,5 +1,5 @@
 use crate::traits::StateExt;
-use anyhow::Result;
+use anyhow::{Context, Result};
 use gw_common::{
     blake2b::new_blake2b,
     builtins::{CKB_SUDT_ACCOUNT_ID, ETH_REGISTRY_ACCOUNT_ID, RESERVED_ACCOUNT_ID},
@@ -13,6 +13,7 @@ use gw_store::{
     state::{
         history::history_state::{HistoryState, RWConfig},
         state_db::StateDB,
+        traits::JournalDB,
     },
     traits::chain_store::ChainStore,
     transaction::StoreTransaction,
@@ -32,7 +33,7 @@ use gw_types::{
 
 /// Build genesis block
 pub fn build_genesis(config: &GenesisConfig, secp_data: Bytes) -> Result<GenesisWithGlobalState> {
-    let store = Store::open_tmp()?;
+    let store = Store::open_tmp().with_context(|| "open tmp")?;
     let db = store.begin_transaction();
     build_genesis_from_store(db, config, secp_data)
         .map(|(_db, genesis_with_state)| genesis_with_state)
@@ -118,6 +119,7 @@ pub fn build_genesis_from_store(
     // insert data_hash into tree
     tree.store_data_hash(secp_data_hash.into())?;
 
+    tree.finalise()?;
     let prev_state_checkpoint: [u8; 32] = tree.calculate_state_checkpoint()?.into();
     let submit_txs = SubmitTransactions::new_builder()
         .prev_state_checkpoint(prev_state_checkpoint.pack())
@@ -125,7 +127,8 @@ pub fn build_genesis_from_store(
 
     // calculate post state
     let post_account = {
-        let root = tree.finalise_root()?;
+        tree.finalise()?;
+        let root = tree.calculate_root()?;
         let count = tree.get_account_count()?;
         AccountMerkleState::new_builder()
             .merkle_root(root.pack())
diff --git a/crates/generator/src/syscalls/mod.rs b/crates/generator/src/syscalls/mod.rs
index dc9a4b64d..f70a306de 100644
--- a/crates/generator/src/syscalls/mod.rs
+++ b/crates/generator/src/syscalls/mod.rs
@@ -18,11 +18,12 @@ use gw_common::{
     H256,
 };
 use gw_config::SyscallCyclesConfig;
+use gw_store::state::traits::JournalDB;
 use gw_traits::{ChainView, CodeStore};
 use gw_types::{
     bytes::Bytes,
     core::ScriptHashType,
-    offchain::{RecoverAccount, RollupContext, RunResult},
+    offchain::{CycleMeter, RollupContext},
     packed::{BlockInfo, LogItem, RawL2Transaction, Script},
     prelude::*,
 };
@@ -66,15 +67,27 @@ const SYS_BN_PAIRING: u64 = 3603;
 /* CKB compatible syscalls */
 const DEBUG_PRINT_SYSCALL_NUMBER: u64 = 2177;
 
+#[derive(Debug, Default)]
+pub struct RunContext {
+    pub cycle_meter: CycleMeter,
+    pub return_data: Bytes,
+    pub exit_code: i8,
+}
+
+impl RunContext {
+    pub fn is_success(&self) -> bool {
+        self.exit_code == 0
+    }
+}
+
 pub(crate) struct L2Syscalls<'a, 'b, S, C> {
     pub(crate) chain: &'a C,
-    pub(crate) state: &'a S,
+    pub(crate) state: &'a mut S,
     pub(crate) rollup_context: &'a RollupContext,
     pub(crate) account_lock_manage: &'a AccountLockManage,
     pub(crate) block_info: &'a BlockInfo,
     pub(crate) raw_tx: &'a RawL2Transaction,
-    pub(crate) code_store: &'a dyn CodeStore,
-    pub(crate) result: &'b mut RunResult,
+    pub(crate) context: &'b mut RunContext,
     pub(crate) cycles_pool: &'b mut Option<&'a mut CyclesPool>,
     pub(crate) log_buf: &'b mut Vec<u8>,
 }
@@ -136,7 +149,7 @@ pub fn store_data<Mac: SupportMachine>(machine: &mut Mac, data: &[u8]) -> Result
     Ok(real_size)
 }
 
-impl<'a, 'b, S: State, C: ChainView, Mac: SupportMachine> Syscalls<Mac>
+impl<'a, 'b, S: State + CodeStore + JournalDB, C: ChainView, Mac: SupportMachine> Syscalls<Mac>
     for L2Syscalls<'a, 'b, S, C>
 {
     fn initialize(&mut self, _machine: &mut Mac) -> Result<(), VMError> {
@@ -149,13 +162,16 @@ impl<'a, 'b, S: State, C: ChainView, Mac: SupportMachine> Syscalls<Mac>
         if let Some(cycles_pool) = self.cycles_pool {
             let syscall_cycles = Self::get_syscall_cycles(code, cycles_pool.syscall_config());
             if 0 != syscall_cycles {
-                self.result.cycles.r#virtual =
-                    self.result.cycles.r#virtual.saturating_add(syscall_cycles);
+                self.context.cycle_meter.r#virtual = self
+                    .context
+                    .cycle_meter
+                    .r#virtual
+                    .saturating_add(syscall_cycles);
 
                 // Subtract cycles to interrupt execution eariler
                 let execution_and_virtual = machine
                     .cycles()
-                    .saturating_add(self.result.cycles.r#virtual);
+                    .saturating_add(self.context.cycle_meter.r#virtual);
                 if cycles_pool.consume_cycles(syscall_cycles).is_none()
                     || execution_and_virtual > cycles_pool.limit()
                 {
@@ -170,7 +186,9 @@ impl<'a, 'b, S: State, C: ChainView, Mac: SupportMachine> Syscalls<Mac>
                 let key = load_data_h256(machine, key_addr)?;
                 let value_addr = machine.registers()[A1].to_u64();
                 let value = load_data_h256(machine, value_addr)?;
-                self.result.write.write_values.insert(key, value);
+                self.state
+                    .update_raw(key, value)
+                    .map_err(|err| VMError::Unexpected(format!("store kv error: {}", err)))?;
                 machine.set_register(A0, Mac::REG::from_u8(SUCCESS));
                 Ok(true)
             }
@@ -178,7 +196,10 @@ impl<'a, 'b, S: State, C: ChainView, Mac: SupportMachine> Syscalls<Mac>
                 let key_addr = machine.registers()[A0].to_u64();
                 let key = load_data_h256(machine, key_addr)?;
                 let value_addr = machine.registers()[A1].to_u64();
-                let value = self.get_raw(&key)?;
+                let value = self
+                    .state
+                    .get_raw(&key)
+                    .map_err(|err| VMError::Unexpected(format!("get raw: {}", err)))?;
                 machine
                     .memory_mut()
                     .store_bytes(value_addr, value.as_slice())?;
@@ -192,7 +213,7 @@ impl<'a, 'b, S: State, C: ChainView, Mac: SupportMachine> Syscalls<Mac>
                     return Err(VMError::Unexpected("exceeded max return data".to_owned()));
                 }
                 let data = load_bytes(machine, data_addr, len as usize)?;
-                self.result.return_data = data.into();
+                self.context.return_data = data.into();
                 machine.set_register(A0, Mac::REG::from_u8(SUCCESS));
                 Ok(true)
             }
@@ -280,15 +301,24 @@ impl<'a, 'b, S: State, C: ChainView, Mac: SupportMachine> Syscalls<Mac>
                 }
 
                 // Same logic from State::create_account()
-                let id = self.get_account_count()?;
-                self.result.write.write_values.insert(
-                    build_account_field_key(id, GW_ACCOUNT_NONCE_TYPE),
-                    H256::zero(),
-                );
-                self.result.write.write_values.insert(
-                    build_account_field_key(id, GW_ACCOUNT_SCRIPT_HASH_TYPE),
-                    script_hash.into(),
-                );
+                let id = self
+                    .state
+                    .get_account_count()
+                    .map_err(|err| VMError::Unexpected(format!("get account count: {}", err)))?;
+                self.state
+                    .update_raw(
+                        build_account_field_key(id, GW_ACCOUNT_NONCE_TYPE),
+                        H256::zero(),
+                    )
+                    .map_err(|err| VMError::Unexpected(format!("store nonce error: {}", err)))?;
+                self.state
+                    .update_raw(
+                        build_account_field_key(id, GW_ACCOUNT_SCRIPT_HASH_TYPE),
+                        script_hash.into(),
+                    )
+                    .map_err(|err| {
+                        VMError::Unexpected(format!("store script hash error: {}", err))
+                    })?;
                 // script hash to id
                 let script_hash_to_id_value: H256 = {
                     let mut buf: [u8; 32] = H256::from_u32(id).into();
@@ -296,16 +326,19 @@ impl<'a, 'b, S: State, C: ChainView, Mac: SupportMachine> Syscalls<Mac>
                     buf[4] = 1;
                     buf.into()
                 };
-                self.result.write.write_values.insert(
-                    build_script_hash_to_account_id_key(&script_hash[..]),
-                    script_hash_to_id_value,
-                );
+                self.state
+                    .update_raw(
+                        build_script_hash_to_account_id_key(&script_hash[..]),
+                        script_hash_to_id_value,
+                    )
+                    .map_err(|err| {
+                        VMError::Unexpected(format!("store script hash to id error: {}", err))
+                    })?;
                 // insert script
-                self.result
-                    .write
-                    .new_scripts
-                    .insert(script_hash.into(), script);
-                self.set_account_count(id + 1);
+                self.state.insert_script(script_hash.into(), script);
+                self.state
+                    .set_account_count(id + 1)
+                    .map_err(|err| VMError::Unexpected(format!("set acccount: {}", err)))?;
                 machine
                     .memory_mut()
                     .store32(&account_id_addr, &Mac::REG::from_u32(id))?;
@@ -337,7 +370,7 @@ impl<'a, 'b, S: State, C: ChainView, Mac: SupportMachine> Syscalls<Mac>
                     machine.set_register(A0, Mac::REG::from_i8(GW_ERROR_ACCOUNT_NOT_FOUND));
                     return Ok(true);
                 }
-                let script = self.get_script(&script_hash).ok_or_else(|| {
+                let script = self.state.get_script(&script_hash).ok_or_else(|| {
                     let err_msg = format!(
                         "syscall error: script not found by script hash: {:?}",
                         script_hash
@@ -361,22 +394,18 @@ impl<'a, 'b, S: State, C: ChainView, Mac: SupportMachine> Syscalls<Mac>
                 hasher.finalize(&mut data_hash);
                 // insert data hash into SMT
                 let data_hash_key = build_data_hash_key(&data_hash);
-                self.result
-                    .write
-                    .write_values
-                    .insert(data_hash_key, H256::one());
+                self.state
+                    .update_raw(data_hash_key, H256::one())
+                    .map_err(|err| VMError::Unexpected(format!("store data: {}", err)))?;
                 // write data
-                self.result
-                    .write
-                    .write_data
-                    .insert(data_hash.into(), data.into());
+                self.state.insert_data(data_hash.into(), data.into());
                 machine.set_register(A0, Mac::REG::from_u8(SUCCESS));
                 Ok(true)
             }
             SYS_LOAD_DATA => {
                 let data_hash_addr = machine.registers()[A3].to_u64();
                 let data_hash = load_data_h256(machine, data_hash_addr)?;
-                let data = match self.get_data(&data_hash) {
+                let data = match self.state.get_data(&data_hash) {
                     Some(data) => data,
                     None => {
                         machine.set_register(A0, Mac::REG::from_i8(GW_ERROR_NOT_FOUND));
@@ -384,7 +413,6 @@ impl<'a, 'b, S: State, C: ChainView, Mac: SupportMachine> Syscalls<Mac>
                     }
                 };
                 store_data(machine, data.as_ref())?;
-                self.result.read_data.insert(data_hash, data);
                 machine.set_register(A0, Mac::REG::from_u8(SUCCESS));
                 Ok(true)
             }
@@ -437,13 +465,6 @@ impl<'a, 'b, S: State, C: ChainView, Mac: SupportMachine> Syscalls<Mac>
                             .args(Bytes::from(script_args).pack())
                             .build();
 
-                        let recover_account = RecoverAccount {
-                            message: msg,
-                            signature,
-                            lock_script: account_script.clone(),
-                        };
-                        self.result.recover_accounts.insert(recover_account);
-
                         machine.memory_mut().store64(
                             &script_len_addr,
                             &Mac::REG::from_u64(account_script.as_slice().len() as u64),
@@ -469,7 +490,7 @@ impl<'a, 'b, S: State, C: ChainView, Mac: SupportMachine> Syscalls<Mac>
                 let data_addr = machine.registers()[A3].to_u64();
 
                 let data = load_bytes(machine, data_addr, data_len as usize)?;
-                self.result.write.logs.push(
+                self.state.append_log(
                     LogItem::new_builder()
                         .account_id(account_id.pack())
                         .service_flag(service_flag.into())
@@ -609,61 +630,9 @@ impl<'a, 'b, S: State, C: ChainView, Mac: SupportMachine> Syscalls<Mac>
 }
 
 impl<'a, 'b, S: State, C: ChainView> L2Syscalls<'a, 'b, S, C> {
-    fn get_raw(&mut self, key: &H256) -> Result<H256, VMError> {
-        let value = match self.result.write.write_values.get(key) {
-            Some(value) => *value,
-            None => {
-                let tree_value = self
-                    .state
-                    .get_raw(key)
-                    .map_err(|err| VMError::Unexpected(err.to_string()))?;
-                self.result.read_values.insert(*key, tree_value);
-                tree_value
-            }
-        };
-        Ok(value)
-    }
-    fn get_account_count(&self) -> Result<u32, VMError> {
-        if let Some(id) = self.result.write.account_count {
-            Ok(id)
-        } else {
-            self.state.get_account_count().map_err(|err| {
-                let err_msg = format!("syscall error: get account count : {:?}", err);
-                log::error!("{}", err_msg);
-                VMError::Unexpected(err_msg)
-            })
-        }
-    }
-    fn set_account_count(&mut self, count: u32) {
-        self.result.write.account_count = Some(count);
-    }
-    fn get_script(&mut self, script_hash: &H256) -> Option<Script> {
-        let opt_script = self
-            .result
-            .write
-            .new_scripts
-            .get(script_hash)
-            .cloned()
-            .or_else(|| self.code_store.get_script(script_hash));
-
-        if let Some(ref script) = opt_script {
-            self.result
-                .get_scripts
-                .insert(*script_hash, script.to_owned());
-        }
-
-        opt_script
-    }
-    fn get_data(&self, data_hash: &H256) -> Option<Bytes> {
-        self.result
-            .write
-            .write_data
-            .get(data_hash)
-            .cloned()
-            .or_else(|| self.code_store.get_data(data_hash))
-    }
     fn get_script_hash(&mut self, id: u32) -> Result<H256, VMError> {
         let value = self
+            .state
             .get_raw(&build_account_field_key(id, GW_ACCOUNT_SCRIPT_HASH_TYPE))
             .map_err(|err| {
                 let err_msg = format!("syscall error: get script hash by account id : {:?}", err);
@@ -677,6 +646,7 @@ impl<'a, 'b, S: State, C: ChainView> L2Syscalls<'a, 'b, S, C> {
         script_hash: &H256,
     ) -> Result<Option<u32>, VMError> {
         let value = self
+            .state
             .get_raw(&build_script_hash_to_account_id_key(script_hash.as_slice()))
             .map_err(|err| {
                 let err_msg = format!("syscall error: get account id by script hash : {:?}", err);
diff --git a/crates/generator/src/tests/dummy_state.rs b/crates/generator/src/tests/dummy_state.rs
index ee14884a9..f49c92056 100644
--- a/crates/generator/src/tests/dummy_state.rs
+++ b/crates/generator/src/tests/dummy_state.rs
@@ -1,239 +1,201 @@
+use ckb_vm::Bytes;
 use gw_common::{
-    error::Error,
-    smt::{default_store::DefaultStore, H256, SMT},
-    state::State,
+    blake2b::new_blake2b, h256_ext::H256Ext, registry_address::RegistryAddress, smt::SMT,
+    state::State, H256,
+};
+use gw_store::{
+    smt::smt_store::SMTStateStore,
+    snapshot::StoreSnapshot,
+    state::{
+        overlay::{mem_state::MemStateTree, mem_store::MemStore},
+        MemStateDB,
+    },
+    Store,
 };
 use gw_traits::CodeStore;
-use gw_types::{bytes::Bytes, packed::Script};
-use std::collections::HashMap;
+use gw_types::{
+    packed::Script,
+    prelude::{Builder, Entity, Pack},
+    U256,
+};
 
-#[derive(Default)]
-pub struct DummyState {
-    tree: SMT<DefaultStore<H256>>,
-    account_count: u32,
-    scripts: HashMap<H256, Script>,
-    codes: HashMap<H256, Bytes>,
-}
+use crate::{traits::StateExt, Error};
 
-impl State for DummyState {
-    fn get_raw(&self, key: &H256) -> Result<H256, Error> {
-        let v = self.tree.get(key)?;
-        Ok(v)
-    }
-    fn update_raw(&mut self, key: H256, value: H256) -> Result<(), Error> {
-        self.tree.update(key, value)?;
-        Ok(())
-    }
-    fn finalise_root(&mut self) -> Result<H256, Error> {
-        let root = *self.tree.root();
-        Ok(root)
-    }
-    fn get_account_count(&self) -> Result<u32, Error> {
-        Ok(self.account_count)
-    }
-    fn set_account_count(&mut self, count: u32) -> Result<(), Error> {
-        self.account_count = count;
-        Ok(())
-    }
+fn new_state(store: StoreSnapshot) -> MemStateDB {
+    let smt = SMT::new(H256::zero(), SMTStateStore::new(MemStore::new(store)));
+    let inner = MemStateTree::new(smt, 0);
+    MemStateDB::new(inner)
 }
 
-impl CodeStore for DummyState {
-    fn insert_script(&mut self, script_hash: H256, script: Script) {
-        self.scripts.insert(script_hash, script);
-    }
-    fn get_script(&self, script_hash: &H256) -> Option<Script> {
-        self.scripts.get(script_hash).cloned()
-    }
-    fn insert_data(&mut self, data_hash: H256, code: Bytes) {
-        self.codes.insert(data_hash, code);
-    }
-    fn get_data(&self, script_hash: &H256) -> Option<Bytes> {
-        self.codes.get(script_hash).cloned()
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use ckb_vm::Bytes;
-    use gw_common::{
-        blake2b::new_blake2b, h256_ext::H256Ext, registry_address::RegistryAddress, state::State,
-        H256,
-    };
-    use gw_traits::CodeStore;
-    use gw_types::{
-        packed::Script,
-        prelude::{Builder, Entity, Pack},
-        U256,
-    };
+#[test]
+fn test_account_with_duplicate_script() {
+    let db = Store::open_tmp().unwrap();
+    let mut tree = new_state(db.get_snapshot());
+    let script = Script::new_builder()
+        .args([0u8; 42].pack())
+        .hash_type(gw_types::core::ScriptHashType::Type.into())
+        .build();
 
-    use crate::{traits::StateExt, Error};
+    // create duplicate account
+    let id = tree.create_account_from_script(script.clone()).unwrap();
+    assert_eq!(id, 0);
+    let err = tree.create_account_from_script(script.clone()).unwrap_err();
+    assert_eq!(
+        err,
+        Error::State(gw_common::error::Error::DuplicatedScriptHash)
+    );
 
-    use super::DummyState;
+    // create duplicate account
+    let err2 = tree.create_account(script.hash().into()).unwrap_err();
+    assert_eq!(err2, gw_common::error::Error::DuplicatedScriptHash);
+}
 
-    #[test]
-    fn test_account_with_duplicate_script() {
-        let mut tree = DummyState::default();
-        let script = Script::new_builder()
-            .args([0u8; 42].pack())
-            .hash_type(gw_types::core::ScriptHashType::Type.into())
-            .build();
+#[test]
+fn test_query_account() {
+    let db = Store::open_tmp().unwrap();
+    let mut tree = new_state(db.get_snapshot());
+    let script_a = Script::new_builder()
+        .args([0u8; 42].pack())
+        .hash_type(gw_types::core::ScriptHashType::Type.into())
+        .build();
+    let script_b = Script::new_builder()
+        .args([1u8; 42].pack())
+        .hash_type(gw_types::core::ScriptHashType::Type.into())
+        .build();
 
-        // create duplicate account
-        let id = tree.create_account_from_script(script.clone()).unwrap();
-        assert_eq!(id, 0);
-        let err = tree.create_account_from_script(script.clone()).unwrap_err();
+    // query account info
+    for (expected_id, script) in [script_a, script_b].iter().enumerate() {
+        let id = tree.create_account_from_script(script.to_owned()).unwrap();
+        assert_eq!(id, expected_id as u32);
+        assert_eq!(tree.get_account_count().unwrap(), (expected_id + 1) as u32);
         assert_eq!(
-            err,
-            Error::State(gw_common::error::Error::DuplicatedScriptHash)
+            tree.get_account_id_by_script_hash(&script.hash().into())
+                .unwrap()
+                .unwrap(),
+            id
         );
-
-        // create duplicate account
-        let err2 = tree.create_account(script.hash().into()).unwrap_err();
-        assert_eq!(err2, gw_common::error::Error::DuplicatedScriptHash);
-    }
-
-    #[test]
-    fn test_query_account() {
-        let mut tree = DummyState::default();
-        let script_a = Script::new_builder()
-            .args([0u8; 42].pack())
-            .hash_type(gw_types::core::ScriptHashType::Type.into())
-            .build();
-        let script_b = Script::new_builder()
-            .args([1u8; 42].pack())
-            .hash_type(gw_types::core::ScriptHashType::Type.into())
-            .build();
-
-        // query account info
-        for (expected_id, script) in [script_a, script_b].iter().enumerate() {
-            let id = tree.create_account_from_script(script.to_owned()).unwrap();
-            assert_eq!(id, expected_id as u32);
-            assert_eq!(tree.get_account_count().unwrap(), (expected_id + 1) as u32);
-            assert_eq!(
-                tree.get_account_id_by_script_hash(&script.hash().into())
-                    .unwrap()
-                    .unwrap(),
-                id
-            );
-            assert_eq!(tree.get_script_hash(id).unwrap(), script.hash().into());
-            assert_eq!(&tree.get_script(&script.hash().into()).unwrap(), script);
-        }
+        assert_eq!(tree.get_script_hash(id).unwrap(), script.hash().into());
+        assert_eq!(&tree.get_script(&script.hash().into()).unwrap(), script);
     }
+}
 
-    #[test]
-    fn test_nonce() {
-        let mut tree = DummyState::default();
-        let script = Script::new_builder()
-            .args([0u8; 42].pack())
-            .hash_type(gw_types::core::ScriptHashType::Type.into())
-            .build();
-        let id = tree.create_account_from_script(script).unwrap();
-        assert_eq!(id, 0);
-        // query account info
-        for i in 1..15 {
-            tree.set_nonce(id, i).unwrap();
-            assert_eq!(tree.get_nonce(id).unwrap(), i);
-        }
+#[test]
+fn test_nonce() {
+    let db = Store::open_tmp().unwrap();
+    let mut tree = new_state(db.get_snapshot());
+    let script = Script::new_builder()
+        .args([0u8; 42].pack())
+        .hash_type(gw_types::core::ScriptHashType::Type.into())
+        .build();
+    let id = tree.create_account_from_script(script).unwrap();
+    assert_eq!(id, 0);
+    // query account info
+    for i in 1..15 {
+        tree.set_nonce(id, i).unwrap();
+        assert_eq!(tree.get_nonce(id).unwrap(), i);
     }
+}
 
-    #[test]
-    fn test_kv() {
-        let mut tree = DummyState::default();
-        let script = Script::new_builder()
-            .args([0u8; 42].pack())
-            .hash_type(gw_types::core::ScriptHashType::Type.into())
-            .build();
-        let id = tree.create_account_from_script(script).unwrap();
-        assert_eq!(id, 0);
-        // query account info
-        for i in 1..15 {
-            let key = H256::from_u32(i as u32);
-            let value = H256::from_u32(i as u32);
-            tree.update_value(id, key.as_slice(), value).unwrap();
-            assert_eq!(tree.get_value(id, key.as_slice()).unwrap(), value);
-        }
+#[test]
+fn test_kv() {
+    let db = Store::open_tmp().unwrap();
+    let mut tree = new_state(db.get_snapshot());
+    let script = Script::new_builder()
+        .args([0u8; 42].pack())
+        .hash_type(gw_types::core::ScriptHashType::Type.into())
+        .build();
+    let id = tree.create_account_from_script(script).unwrap();
+    assert_eq!(id, 0);
+    // query account info
+    for i in 1..15 {
+        let key = H256::from_u32(i as u32);
+        let value = H256::from_u32(i as u32);
+        tree.update_value(id, key.as_slice(), value).unwrap();
+        assert_eq!(tree.get_value(id, key.as_slice()).unwrap(), value);
     }
+}
 
-    #[test]
-    fn test_sudt() {
-        let mut tree = DummyState::default();
-        let script = Script::new_builder()
-            .args([0u8; 42].pack())
-            .hash_type(gw_types::core::ScriptHashType::Type.into())
-            .build();
-        let id = tree.create_account_from_script(script).unwrap();
-        assert_eq!(id, 0);
-        let script = Script::new_builder()
-            .args([1u8; 42].pack())
-            .hash_type(gw_types::core::ScriptHashType::Type.into())
-            .build();
-        let sudt_id = tree.create_account_from_script(script).unwrap();
-        assert_eq!(sudt_id, 1);
-        // mint sudt
-        let user_a = RegistryAddress::new(0, vec![1u8; 20]);
-        let user_b = RegistryAddress::new(0, vec![2u8; 20]);
-        tree.mint_sudt(sudt_id, &user_a, U256::from(100u64))
-            .unwrap();
-        assert_eq!(
-            tree.get_sudt_total_supply(sudt_id).unwrap(),
-            U256::from(100)
-        );
-        tree.mint_sudt(sudt_id, &user_a, U256::from(230u64))
-            .unwrap();
-        assert_eq!(
-            tree.get_sudt_total_supply(sudt_id).unwrap(),
-            U256::from(330)
-        );
-        tree.mint_sudt(sudt_id, &user_b, U256::from(155u64))
-            .unwrap();
-        assert_eq!(
-            tree.get_sudt_total_supply(sudt_id).unwrap(),
-            U256::from(485)
-        );
-        // burn sudt
-        tree.burn_sudt(sudt_id, &user_a, U256::from(85u64)).unwrap();
-        assert_eq!(
-            tree.get_sudt_total_supply(sudt_id).unwrap(),
-            U256::from(400)
-        );
-        // overdraft
-        let err = tree
-            .burn_sudt(sudt_id, &user_b, U256::from(200u64))
-            .unwrap_err();
-        assert_eq!(err, gw_common::error::Error::AmountOverflow);
-        assert_eq!(
-            tree.get_sudt_total_supply(sudt_id).unwrap(),
-            U256::from(400)
-        );
-        tree.burn_sudt(sudt_id, &user_b, U256::from(100u64))
-            .unwrap();
-        assert_eq!(
-            tree.get_sudt_total_supply(sudt_id).unwrap(),
-            U256::from(300)
-        );
-    }
+#[test]
+fn test_sudt() {
+    let db = Store::open_tmp().unwrap();
+    let mut tree = new_state(db.get_snapshot());
+    let script = Script::new_builder()
+        .args([0u8; 42].pack())
+        .hash_type(gw_types::core::ScriptHashType::Type.into())
+        .build();
+    let id = tree.create_account_from_script(script).unwrap();
+    assert_eq!(id, 0);
+    let script = Script::new_builder()
+        .args([1u8; 42].pack())
+        .hash_type(gw_types::core::ScriptHashType::Type.into())
+        .build();
+    let sudt_id = tree.create_account_from_script(script).unwrap();
+    assert_eq!(sudt_id, 1);
+    // mint sudt
+    let user_a = RegistryAddress::new(0, vec![1u8; 20]);
+    let user_b = RegistryAddress::new(0, vec![2u8; 20]);
+    tree.mint_sudt(sudt_id, &user_a, U256::from(100u64))
+        .unwrap();
+    assert_eq!(
+        tree.get_sudt_total_supply(sudt_id).unwrap(),
+        U256::from(100)
+    );
+    tree.mint_sudt(sudt_id, &user_a, U256::from(230u64))
+        .unwrap();
+    assert_eq!(
+        tree.get_sudt_total_supply(sudt_id).unwrap(),
+        U256::from(330)
+    );
+    tree.mint_sudt(sudt_id, &user_b, U256::from(155u64))
+        .unwrap();
+    assert_eq!(
+        tree.get_sudt_total_supply(sudt_id).unwrap(),
+        U256::from(485)
+    );
+    // burn sudt
+    tree.burn_sudt(sudt_id, &user_a, U256::from(85u64)).unwrap();
+    assert_eq!(
+        tree.get_sudt_total_supply(sudt_id).unwrap(),
+        U256::from(400)
+    );
+    // overdraft
+    let err = tree
+        .burn_sudt(sudt_id, &user_b, U256::from(200u64))
+        .unwrap_err();
+    assert_eq!(err, gw_common::error::Error::AmountOverflow);
+    assert_eq!(
+        tree.get_sudt_total_supply(sudt_id).unwrap(),
+        U256::from(400)
+    );
+    tree.burn_sudt(sudt_id, &user_b, U256::from(100u64))
+        .unwrap();
+    assert_eq!(
+        tree.get_sudt_total_supply(sudt_id).unwrap(),
+        U256::from(300)
+    );
+}
 
-    #[test]
-    fn test_data_hash() {
-        let mut tree = DummyState::default();
-        let data = [42u8; 42];
-        let data_hash = {
-            let mut hasher = new_blake2b();
-            let mut buf = [0u8; 32];
-            hasher.update(&data);
-            hasher.finalize(&mut buf);
-            buf.into()
-        };
-        tree.insert_data(data_hash, data.to_vec().into());
-        // query data
-        assert_eq!(
-            tree.get_data(&data_hash).unwrap(),
-            Bytes::from(data.to_vec())
-        );
-        // store data hash
-        assert!(!tree.is_data_hash_exist(&data_hash).unwrap());
-        assert!(!tree.is_data_hash_exist(&H256::zero()).unwrap());
-        tree.store_data_hash(data_hash).unwrap();
-        assert!(tree.is_data_hash_exist(&data_hash).unwrap());
-    }
+#[test]
+fn test_data_hash() {
+    let db = Store::open_tmp().unwrap();
+    let mut tree = new_state(db.get_snapshot());
+    let data = [42u8; 42];
+    let data_hash = {
+        let mut hasher = new_blake2b();
+        let mut buf = [0u8; 32];
+        hasher.update(&data);
+        hasher.finalize(&mut buf);
+        buf.into()
+    };
+    tree.insert_data(data_hash, data.to_vec().into());
+    // query data
+    assert_eq!(
+        tree.get_data(&data_hash).unwrap(),
+        Bytes::from(data.to_vec())
+    );
+    // store data hash
+    assert!(!tree.is_data_hash_exist(&data_hash).unwrap());
+    assert!(!tree.is_data_hash_exist(&H256::zero()).unwrap());
+    tree.store_data_hash(data_hash).unwrap();
+    assert!(tree.is_data_hash_exist(&data_hash).unwrap());
 }
diff --git a/crates/generator/src/traits.rs b/crates/generator/src/traits.rs
index 0b60d8971..eb1e541b3 100644
--- a/crates/generator/src/traits.rs
+++ b/crates/generator/src/traits.rs
@@ -4,8 +4,9 @@ use gw_common::ckb_decimal::{CKBCapacity, CKB_DECIMAL_POW_EXP};
 use gw_common::registry::context::RegistryContext;
 use gw_common::registry_address::RegistryAddress;
 use gw_common::{builtins::CKB_SUDT_ACCOUNT_ID, state::State, CKB_SUDT_SCRIPT_ARGS, H256};
+use gw_store::state::traits::JournalDB;
 use gw_traits::CodeStore;
-use gw_types::offchain::{RollupContext, RunResultWriteState};
+use gw_types::offchain::RollupContext;
 use gw_types::U256;
 use gw_types::{
     core::ScriptHashType,
@@ -16,8 +17,7 @@ use tracing::instrument;
 
 pub trait StateExt {
     fn create_account_from_script(&mut self, script: Script) -> Result<u32, Error>;
-    fn finalise_merkle_state(&mut self) -> Result<AccountMerkleState, Error>;
-    fn apply_run_result(&mut self, write: &RunResultWriteState) -> Result<(), Error>;
+    fn calculate_merkle_state(&self) -> Result<AccountMerkleState, Error>;
     fn apply_deposit_request(
         &mut self,
         ctx: &RollupContext,
@@ -38,25 +38,9 @@ pub trait StateExt {
         sudt_id: u32,
         amount: U256,
     ) -> Result<(), Error>;
-
-    fn apply_withdrawal_requests(
-        &mut self,
-        ctx: &RollupContext,
-        block_producer: &RegistryAddress,
-        withdrawal_requests: &[WithdrawalRequest],
-    ) -> Result<Vec<WithdrawalReceipt>, Error> {
-        let mut receipts = Vec::with_capacity(withdrawal_requests.len());
-
-        for request in withdrawal_requests {
-            let receipt = self.apply_withdrawal_request(ctx, block_producer, request)?;
-            receipts.push(receipt);
-        }
-
-        Ok(receipts)
-    }
 }
 
-impl<S: State + CodeStore> StateExt for S {
+impl<S: State + CodeStore + JournalDB> StateExt for S {
     fn create_account_from_script(&mut self, script: Script) -> Result<u32, Error> {
         // Godwoken requires account's script using ScriptHashType::Type
         if script.hash_type() != ScriptHashType::Type.into() {
@@ -68,10 +52,9 @@ impl<S: State + CodeStore> StateExt for S {
         Ok(id)
     }
 
-    /// Finalise and return current merkle state
-    /// See finalise for drtails
-    fn finalise_merkle_state(&mut self) -> Result<AccountMerkleState, Error> {
-        let account_root = self.finalise_root()?;
+    /// return current merkle state
+    fn calculate_merkle_state(&self) -> Result<AccountMerkleState, Error> {
+        let account_root = self.calculate_root()?;
         let account_count = self.get_account_count()?;
         let merkle_state = AccountMerkleState::new_builder()
             .merkle_root(account_root.pack())
@@ -80,24 +63,6 @@ impl<S: State + CodeStore> StateExt for S {
         Ok(merkle_state)
     }
 
-    #[instrument(skip_all)]
-    fn apply_run_result(&mut self, write: &RunResultWriteState) -> Result<(), Error> {
-        for (k, v) in &write.write_values {
-            self.update_raw(*k, *v)?;
-        }
-        if let Some(id) = write.account_count {
-            self.set_account_count(id)?;
-        }
-        for (script_hash, script) in &write.new_scripts {
-            self.insert_script(*script_hash, script.to_owned());
-        }
-        for (data_hash, data) in &write.write_data {
-            self.insert_data(*data_hash, data.clone());
-        }
-
-        Ok(())
-    }
-
     fn pay_fee(
         &mut self,
         payer: &RegistryAddress,
@@ -256,7 +221,8 @@ impl<S: State + CodeStore> StateExt for S {
         self.set_nonce(id, new_nonce)?;
 
         let post_state = {
-            let account_root = self.finalise_root()?;
+            self.finalise()?;
+            let account_root = self.calculate_root()?;
             let account_count = self.get_account_count()?;
             AccountMerkleState::new_builder()
                 .merkle_root(account_root.pack())
diff --git a/crates/generator/src/types/mod.rs b/crates/generator/src/types/mod.rs
index d1e6c39bf..e44013b9b 100644
--- a/crates/generator/src/types/mod.rs
+++ b/crates/generator/src/types/mod.rs
@@ -1,2 +1 @@
-pub mod run_result_state;
 pub mod vm;
diff --git a/crates/generator/src/types/run_result_state.rs b/crates/generator/src/types/run_result_state.rs
deleted file mode 100644
index f317aca7c..000000000
--- a/crates/generator/src/types/run_result_state.rs
+++ /dev/null
@@ -1,48 +0,0 @@
-use gw_common::{state::State, H256};
-use gw_traits::CodeStore;
-use gw_types::{bytes::Bytes, offchain::RunResult};
-
-pub struct RunResultState<'a>(pub &'a mut RunResult);
-
-impl<'a> State for RunResultState<'a> {
-    fn get_raw(&self, key: &H256) -> Result<H256, gw_common::error::Error> {
-        self.0
-            .read_values
-            .get(key)
-            .cloned()
-            .ok_or(gw_common::error::Error::MissingKey)
-    }
-    fn update_raw(&mut self, key: H256, value: H256) -> Result<(), gw_common::error::Error> {
-        self.0.write.write_values.insert(key, value);
-        Ok(())
-    }
-    fn finalise_root(&mut self) -> Result<H256, gw_common::error::Error> {
-        // unsupported operation
-        Err(gw_common::error::Error::MissingKey)
-    }
-    fn get_account_count(&self) -> Result<u32, gw_common::error::Error> {
-        self.0
-            .write
-            .account_count
-            .ok_or(gw_common::error::Error::MissingKey)
-    }
-    fn set_account_count(&mut self, count: u32) -> Result<(), gw_common::error::Error> {
-        self.0.write.account_count = Some(count);
-        Ok(())
-    }
-}
-
-impl<'a> CodeStore for RunResultState<'a> {
-    fn get_data(&self, data_hash: &H256) -> Option<Bytes> {
-        self.0.read_data.get(data_hash).cloned()
-    }
-    fn insert_data(&mut self, data_hash: H256, code: Bytes) {
-        self.0.write.write_data.insert(data_hash, code);
-    }
-    fn get_script(&self, script_hash: &H256) -> Option<gw_types::packed::Script> {
-        self.0.get_scripts.get(script_hash).cloned()
-    }
-    fn insert_script(&mut self, script_hash: H256, script: gw_types::packed::Script) {
-        self.0.write.new_scripts.insert(script_hash, script);
-    }
-}
diff --git a/crates/jsonrpc-types/src/godwoken.rs b/crates/jsonrpc-types/src/godwoken.rs
index 889c5f348..d07f4a884 100644
--- a/crates/jsonrpc-types/src/godwoken.rs
+++ b/crates/jsonrpc-types/src/godwoken.rs
@@ -1153,11 +1153,11 @@ pub struct RunResult {
 impl From<offchain::RunResult> for RunResult {
     fn from(data: offchain::RunResult) -> RunResult {
         let offchain::RunResult {
-            return_data, write, ..
+            return_data, logs, ..
         } = data;
         RunResult {
             return_data: JsonBytes::from_bytes(return_data),
-            logs: write.logs.into_iter().map(Into::into).collect(),
+            logs: logs.into_iter().map(Into::into).collect(),
         }
     }
 }
diff --git a/crates/mem-pool/src/pool.rs b/crates/mem-pool/src/pool.rs
index 2f74c3a6a..04df21812 100644
--- a/crates/mem-pool/src/pool.rs
+++ b/crates/mem-pool/src/pool.rs
@@ -26,7 +26,7 @@ use gw_generator::{
 use gw_store::{
     chain_view::ChainView,
     mem_pool_state::{self, MemPoolState, Shared},
-    state::MemStateDB,
+    state::{traits::JournalDB, MemStateDB},
     traits::chain_store::ChainStore,
     transaction::StoreTransaction,
     Store,
@@ -947,13 +947,14 @@ impl MemPool {
             state.apply_deposit_request(self.generator.rollup_context(), &deposit)?;
             let touched_keys = state.state_tracker().unwrap().touched_keys();
             touched_keys_vec.push(touched_keys.lock().unwrap().drain().collect());
-            post_states.push(state.finalise_merkle_state()?);
+            state.finalise()?;
+            post_states.push(state.calculate_merkle_state()?);
         }
         state.take_state_tracker();
         // calculate state after withdrawals & deposits
         let prev_state_checkpoint = state.calculate_state_checkpoint()?;
         log::debug!("[finalize deposits] deposits: {} state root: {}, account count: {}, prev_state_checkpoint {}",
-         deposit_cells.len(), hex::encode(state.finalise_root()?.as_slice()), state.get_account_count()?, hex::encode(prev_state_checkpoint.as_slice()));
+         deposit_cells.len(), hex::encode(state.calculate_root()?.as_slice()), state.get_account_count()?, hex::encode(prev_state_checkpoint.as_slice()));
 
         self.mem_block.push_deposits(
             deposit_cells,
@@ -1028,13 +1029,15 @@ impl MemPool {
             }
 
             // update the state
+            let snap = state.snapshot();
             match state.apply_withdrawal_request(
                 self.generator.rollup_context(),
                 self.mem_block.block_producer(),
                 &withdrawal.request(),
             ) {
                 Ok(_) => {
-                    let post_state = state.finalise_merkle_state()?;
+                    state.finalise()?;
+                    let post_state = state.calculate_merkle_state()?;
                     let touched_keys = state.state_tracker().unwrap().touched_keys();
 
                     let withdrawal_hash = withdrawal.hash().into();
@@ -1061,6 +1064,7 @@ impl MemPool {
                 }
                 Err(err) => {
                     log::info!("[mem-pool] withdrawal execution failed : {}", err);
+                    state.revert(snap)?;
                     unused_withdrawals.push(withdrawal_hash);
                 }
             }
@@ -1120,14 +1124,21 @@ impl MemPool {
 
         // execute tx
         let raw_tx = tx.raw();
-        let run_result = generator.unchecked_execute_transaction(
-            &chain_view,
-            state,
-            block_info,
-            &raw_tx,
-            L2TX_MAX_CYCLES,
-            Some(cycles_pool),
-        )?;
+        let snap = state.snapshot();
+        let run_result = generator
+            .unchecked_execute_transaction(
+                &chain_view,
+                state,
+                block_info,
+                &raw_tx,
+                L2TX_MAX_CYCLES,
+                Some(cycles_pool),
+            )
+            .map_err(|err| {
+                // revert state
+                state.revert(snap).unwrap();
+                err
+            })?;
 
         // check account id of sudt proxy contract creator is from whitelist
         {
@@ -1138,22 +1149,20 @@ impl MemPool {
                 .get_sudt_proxy_account_whitelist()
                 .validate(&run_result, from_id)
             {
+                // revert state
+                state.revert(snap)?;
                 return Err(TransactionError::InvalidSUDTProxyCreatorAccount {
                     account_id: from_id,
                 }
                 .into());
             }
         }
-        // apply run result
-        let t = Instant::now();
-        state.apply_run_result(&run_result.write)?;
-        log::debug!(
-            "[finalize tx] apply run result: {}ms",
-            t.elapsed().as_millis()
-        );
+
+        state.finalise()?;
+        // finalise dirty state
+        let merkle_state = state.calculate_merkle_state()?;
 
         // generate tx receipt
-        let merkle_state = state.finalise_merkle_state()?;
         let tx_receipt =
             TxReceipt::build_receipt(tx.witness_hash().into(), run_result, merkle_state);
 
diff --git a/crates/polyjuice-sender-recover/Cargo.toml b/crates/polyjuice-sender-recover/Cargo.toml
index cbb6016ed..6dcd58622 100644
--- a/crates/polyjuice-sender-recover/Cargo.toml
+++ b/crates/polyjuice-sender-recover/Cargo.toml
@@ -12,6 +12,7 @@ gw-generator = { path = "../generator" }
 gw-traits = { path = "../traits" }
 gw-types = { path = "../types" }
 gw-utils = { path = "../utils" }
+gw-store = { path = "../store" }
 log = "0.4"
 thiserror = "1.0"
 tracing = { version = "0.1", features = ["attributes"] }
diff --git a/crates/polyjuice-sender-recover/src/mem_execute_tx_state.rs b/crates/polyjuice-sender-recover/src/mem_execute_tx_state.rs
index dbe2f148e..cbae6af1c 100644
--- a/crates/polyjuice-sender-recover/src/mem_execute_tx_state.rs
+++ b/crates/polyjuice-sender-recover/src/mem_execute_tx_state.rs
@@ -1,97 +1,23 @@
 use anyhow::Result;
-use gw_common::error::Error as StateError;
 use gw_common::registry_address::RegistryAddress;
 use gw_common::state::State;
 use gw_common::H256;
 use gw_generator::traits::StateExt;
+use gw_store::state::traits::JournalDB;
 use gw_traits::CodeStore;
-use gw_types::bytes::Bytes;
-use gw_types::offchain::RunResult;
 use gw_types::packed::Script;
 
-pub struct MemExecuteTxStateTree<S: State> {
-    readonly_state: S,
-    overlay: RunResult,
-}
-
-impl<S: State + CodeStore> MemExecuteTxStateTree<S> {
-    pub fn new(readonly_state: S) -> Self {
-        Self {
-            readonly_state,
-            overlay: Default::default(),
-        }
-    }
-
-    pub fn mock_account(
-        &mut self,
-        registry_address: RegistryAddress,
-        account_script: Script,
-    ) -> Result<u32> {
-        let account_script_hash: H256 = account_script.hash().into();
-        if let Some(account_id) = self
-            .readonly_state
-            .get_account_id_by_script_hash(&account_script_hash)?
-        {
-            return Ok(account_id);
-        }
-
-        let account_id = self.create_account_from_script(account_script)?;
-        self.mapping_registry_address_to_script_hash(registry_address, account_script_hash)?;
-        Ok(account_id)
-    }
-}
-
-impl<S: State + CodeStore> State for MemExecuteTxStateTree<S> {
-    fn get_raw(&self, key: &H256) -> Result<H256, StateError> {
-        match self.overlay.write.write_values.get(key) {
-            Some(value) => Ok(*value),
-            None => self.readonly_state.get_raw(key),
-        }
-    }
-
-    fn update_raw(&mut self, key: H256, value: H256) -> Result<(), StateError> {
-        self.overlay.write.write_values.insert(key, value);
-        Ok(())
-    }
-
-    fn get_account_count(&self) -> Result<u32, StateError> {
-        match self.overlay.write.account_count {
-            Some(count) => Ok(count),
-            None => self.readonly_state.get_account_count(),
-        }
+pub fn mock_account<S: State + CodeStore + JournalDB>(
+    state: &mut S,
+    registry_address: RegistryAddress,
+    account_script: Script,
+) -> Result<u32> {
+    let account_script_hash: H256 = account_script.hash().into();
+    if let Some(account_id) = state.get_account_id_by_script_hash(&account_script_hash)? {
+        return Ok(account_id);
     }
 
-    fn set_account_count(&mut self, count: u32) -> Result<(), StateError> {
-        self.overlay.write.account_count = Some(count);
-        Ok(())
-    }
-
-    fn finalise_root(&mut self) -> Result<H256, StateError> {
-        log::error!("calculate_root is unsupport in executetx state");
-        Err(StateError::Store)
-    }
-}
-
-impl<S: State + CodeStore> CodeStore for MemExecuteTxStateTree<S> {
-    fn insert_script(&mut self, script_hash: H256, script: Script) {
-        self.overlay.write.new_scripts.insert(script_hash, script);
-    }
-
-    fn get_script(&self, script_hash: &H256) -> Option<Script> {
-        match self.overlay.write.new_scripts.get(script_hash) {
-            Some(script) => Some(script.to_owned()),
-            None => self.readonly_state.get_script(script_hash),
-        }
-    }
-
-    fn insert_data(&mut self, data_hash: H256, code: Bytes) {
-        self.overlay.write.write_data.insert(data_hash, code);
-    }
-
-    fn get_data(&self, data_hash: &H256) -> Option<Bytes> {
-        match self.overlay.write.write_data.get(data_hash) {
-            Some(data) => Some(data.to_owned()),
-            None => self.readonly_state.get_data(data_hash),
-        }
-    }
+    let account_id = state.create_account_from_script(account_script)?;
+    state.mapping_registry_address_to_script_hash(registry_address, account_script_hash)?;
+    Ok(account_id)
 }
diff --git a/crates/polyjuice-sender-recover/src/recover/eth_recover.rs b/crates/polyjuice-sender-recover/src/recover/eth_recover.rs
index e0cd29f15..0da4de677 100644
--- a/crates/polyjuice-sender-recover/src/recover/eth_recover.rs
+++ b/crates/polyjuice-sender-recover/src/recover/eth_recover.rs
@@ -5,6 +5,7 @@ use gw_common::{
     builtins::CKB_SUDT_ACCOUNT_ID, registry_address::RegistryAddress, state::State, H256,
 };
 use gw_generator::{error::TransactionError, typed_transaction::types::TypedRawTransaction};
+use gw_store::state::{traits::JournalDB, MemStateDB};
 use gw_traits::CodeStore;
 use gw_types::{
     bytes::Bytes,
@@ -16,7 +17,7 @@ use gw_types::{
 use gw_utils::wallet::Wallet;
 use tracing::instrument;
 
-use crate::mem_execute_tx_state::MemExecuteTxStateTree;
+use crate::mem_execute_tx_state::mock_account;
 
 use super::{
     error::PolyjuiceTxSenderRecoverError, eth_account_creator::EthAccountCreator,
@@ -205,10 +206,10 @@ impl EthRecover {
         }
     }
 
-    pub fn mock_sender_if_not_exists<S: State + CodeStore>(
+    pub fn mock_sender_if_not_exists(
         &self,
         tx: L2Transaction,
-        state: &mut MemExecuteTxStateTree<S>,
+        state: &mut MemStateDB,
     ) -> Result<L2Transaction, PolyjuiceTxSenderRecoverError> {
         let sender_id: u32 = tx.raw().from_id().unpack();
         if 0 != sender_id {
@@ -228,7 +229,7 @@ impl EthRecover {
                     tx_hash,
                 );
 
-                state.mock_account(registry_address, account_script)?
+                mock_account(state, registry_address, account_script)?
             }
         };
 
@@ -245,11 +246,11 @@ impl EthRecover {
         Ok(tx)
     }
 
-    pub fn mock_sender_if_not_exists_from_raw_registry<S: State + CodeStore>(
+    pub fn mock_sender_if_not_exists_from_raw_registry<S: State + CodeStore + JournalDB>(
         &self,
         raw_tx: RawL2Transaction,
         opt_registry_address: Option<RegistryAddress>,
-        state: &mut MemExecuteTxStateTree<S>,
+        state: &mut S,
     ) -> Result<RawL2Transaction> {
         let sender_id: u32 = raw_tx.from_id().unpack();
         if 0 != sender_id {
@@ -269,7 +270,7 @@ impl EthRecover {
         );
 
         let account_script = self.account_context.to_account_script(&registry_address);
-        let account_id = state.mock_account(registry_address, account_script)?;
+        let account_id = mock_account(state, registry_address, account_script)?;
         let raw_tx = raw_tx.as_builder().from_id(account_id.pack()).build();
 
         log::debug!(
diff --git a/crates/rpc-server/src/registry.rs b/crates/rpc-server/src/registry.rs
index ababac4b4..ad25e39e5 100644
--- a/crates/rpc-server/src/registry.rs
+++ b/crates/rpc-server/src/registry.rs
@@ -32,9 +32,7 @@ use gw_mem_pool::fee::{
     queue::FeeQueue,
     types::{FeeEntry, FeeItem, FeeItemKind, FeeItemSender},
 };
-use gw_polyjuice_sender_recover::{
-    mem_execute_tx_state::MemExecuteTxStateTree, recover::PolyjuiceSenderRecover,
-};
+use gw_polyjuice_sender_recover::recover::PolyjuiceSenderRecover;
 use gw_rpc_client::rpc_client::RPCClient;
 use gw_store::state::history::history_state::RWConfig;
 use gw_store::state::{BlockStateDB, MemStateDB};
@@ -1024,8 +1022,7 @@ async fn execute_l2transaction(
         let db = ctx.store.get_snapshot();
         let tip_block_hash = db.get_last_valid_tip_block_hash()?;
         let chain_view = ChainView::new(&db, tip_block_hash);
-        let state = ctx.mem_pool_state.load_state_db();
-        let mut state = MemExecuteTxStateTree::new(state);
+        let mut state = ctx.mem_pool_state.load_state_db();
         let mut cycles_pool = CyclesPool::new(
             ctx.mem_pool_config.mem_block.max_cycles_limit,
             ctx.mem_pool_config.mem_block.syscall_cycles.clone(),
@@ -1049,7 +1046,7 @@ async fn execute_l2transaction(
         let raw_tx = tx.raw();
         let run_result = ctx.generator.unchecked_execute_transaction(
             &chain_view,
-            &state,
+            &mut state,
             &block_info,
             &raw_tx,
             100000000,
@@ -1065,7 +1062,7 @@ async fn execute_l2transaction(
             tx_hash: tx_hash.into(),
             block_number: number,
             return_data: run_result.return_data,
-            last_log: run_result.write.logs.pop(),
+            last_log: run_result.logs.pop(),
             exit_code: run_result.exit_code,
         };
 
@@ -1183,9 +1180,8 @@ async fn execute_raw_l2transaction(
         // execute tx
         let run_result = match block_number_opt {
             Some(block_number) => {
-                let history_state =
+                let mut state =
                     BlockStateDB::from_store(db, RWConfig::history_block(block_number))?;
-                let mut state = MemExecuteTxStateTree::new(history_state);
                 let raw_l2tx = eth_recover.mock_sender_if_not_exists_from_raw_registry(
                     raw_l2tx,
                     registry_address_opt,
@@ -1198,7 +1194,7 @@ async fn execute_raw_l2transaction(
 
                 ctx.generator.unchecked_execute_transaction(
                     &chain_view,
-                    &state,
+                    &mut state,
                     &block_info,
                     &raw_l2tx,
                     execute_l2tx_max_cycles,
@@ -1206,8 +1202,7 @@ async fn execute_raw_l2transaction(
                 )?
             }
             None => {
-                let state = ctx.mem_pool_state.load_state_db();
-                let mut state = MemExecuteTxStateTree::new(state);
+                let mut state = ctx.mem_pool_state.load_state_db();
                 let raw_l2tx = eth_recover.mock_sender_if_not_exists_from_raw_registry(
                     raw_l2tx,
                     registry_address_opt,
@@ -1220,7 +1215,7 @@ async fn execute_raw_l2transaction(
 
                 ctx.generator.unchecked_execute_transaction(
                     &chain_view,
-                    &state,
+                    &mut state,
                     &block_info,
                     &raw_l2tx,
                     execute_l2tx_max_cycles,
@@ -1237,7 +1232,7 @@ async fn execute_raw_l2transaction(
             tx_hash,
             block_number,
             return_data: run_result.return_data,
-            last_log: run_result.write.logs.pop(),
+            last_log: run_result.logs.pop(),
             exit_code: run_result.exit_code,
         };
 
diff --git a/crates/store/src/state/history/history_state.rs b/crates/store/src/state/history/history_state.rs
index 7b2ec7963..5dc320a00 100644
--- a/crates/store/src/state/history/history_state.rs
+++ b/crates/store/src/state/history/history_state.rs
@@ -221,7 +221,7 @@ impl<Store: KVStore + HistoryStateStore + CodeStore> State for HistoryState<Stor
         Ok(())
     }
 
-    fn finalise_root(&mut self) -> Result<H256, StateError> {
+    fn calculate_root(&self) -> Result<H256, StateError> {
         let root = self.tree.root();
         Ok(*root)
     }
diff --git a/crates/store/src/state/overlay/mem_state.rs b/crates/store/src/state/overlay/mem_state.rs
index c5f078cd2..a7658f133 100644
--- a/crates/store/src/state/overlay/mem_state.rs
+++ b/crates/store/src/state/overlay/mem_state.rs
@@ -41,17 +41,6 @@ impl MemStateTree {
         &self.tree
     }
 
-    // /// submit tree changes into memory block
-    // /// notice, this function do not commit the DBTransaction
-    // pub fn submit_tree_to_mem_block(&self) {
-    //     self.db()
-    //         .set_mem_block_account_smt_root(*self.tree.root())
-    //         .expect("set smt root");
-    //     self.db()
-    //         .set_mem_block_account_count(self.account_count)
-    //         .expect("set smt root");
-    // }
-
     fn db(&self) -> &SMTStateStore<MemStore> {
         self.tree.store()
     }
@@ -86,7 +75,7 @@ impl State for MemStateTree {
         Ok(())
     }
 
-    fn finalise_root(&mut self) -> Result<H256, StateError> {
+    fn calculate_root(&self) -> Result<H256, StateError> {
         let root = self.tree.root();
         Ok(*root)
     }
diff --git a/crates/store/src/state/state_db.rs b/crates/store/src/state/state_db.rs
index 7ee05057e..9644c98a4 100644
--- a/crates/store/src/state/state_db.rs
+++ b/crates/store/src/state/state_db.rs
@@ -7,13 +7,16 @@
 //! - FileDB (RocksDB)
 //!
 
-use std::{collections::HashSet, sync::Mutex};
+use std::{
+    collections::{HashMap, HashSet},
+    sync::Mutex,
+};
 
-use anyhow::{anyhow, Result};
+use anyhow::Result;
 use gw_traits::CodeStore;
 use gw_types::{
     bytes::Bytes,
-    packed,
+    packed::{self, LogItem},
     prelude::{Pack, Unpack},
 };
 
@@ -29,6 +32,7 @@ use crate::{
 use super::{
     history::history_state::RWConfig,
     overlay::{mem_state::MemStateTree, mem_store::MemStore},
+    traits::JournalDB,
     BlockStateDB, MemStateDB,
 };
 
@@ -38,6 +42,7 @@ pub enum JournalEntry {
     SetAccountCount { prev_count: u32 },
     InsertScript { script_hash: H256, prev_exist: bool },
     InsertData { data_hash: H256, prev_exist: bool },
+    AppendLog { index: usize },
 }
 
 impl JournalEntry {
@@ -68,6 +73,10 @@ impl JournalEntry {
                     state_db.dirty_data.remove(&data_hash);
                 }
             }
+            AppendLog { index } => {
+                assert_eq!(state_db.dirty_logs.len(), index + 1);
+                state_db.dirty_logs.pop_back();
+            }
         }
     }
 }
@@ -110,6 +119,8 @@ pub struct Revision {
 #[derive(Debug, Default)]
 pub struct StateTracker {
     touched_keys: Mutex<HashSet<H256>>,
+    write_data: Mutex<HashMap<H256, Bytes>>,
+    read_data: Mutex<HashMap<H256, Bytes>>,
 }
 
 impl StateTracker {
@@ -118,14 +129,17 @@ impl StateTracker {
         &self.touched_keys
     }
 
-    /// Record a key in the tracker
-    pub fn touch_key(&self, key: &H256) {
-        self.touched_keys.lock().unwrap().insert(*key);
+    pub fn write_data(&self) -> &Mutex<HashMap<H256, Bytes>> {
+        &self.write_data
+    }
+
+    pub fn read_data(&self) -> &Mutex<HashMap<H256, Bytes>> {
+        &self.read_data
     }
 
     /// Record a key in the tracker
-    pub fn clear(&mut self) {
-        self.touched_keys.lock().unwrap().clear();
+    pub fn touch_key(&self, key: &H256) {
+        self.touched_keys.lock().unwrap().insert(*key);
     }
 }
 
@@ -146,6 +160,8 @@ pub struct StateDB<S> {
     dirty_scripts: im::HashMap<H256, packed::Script>,
     /// dirty data
     dirty_data: im::HashMap<H256, Bytes>,
+    /// dirty logs
+    dirty_logs: im::Vector<LogItem>,
     /// state tracker
     state_tracker: Option<StateTracker>,
     /// last state root
@@ -163,6 +179,7 @@ impl<S: Clone> Clone for StateDB<S> {
             dirty_account_count: self.dirty_account_count,
             dirty_scripts: self.dirty_scripts.clone(),
             dirty_data: self.dirty_data.clone(),
+            dirty_logs: self.dirty_logs.clone(),
             state_tracker: None,
             last_state_root: self.last_state_root,
         }
@@ -207,8 +224,7 @@ impl<Store: ChainStore + HistoryStateStore + CodeStore + KVStore> BlockStateDB<S
 }
 
 impl<S: State + CodeStore> StateDB<S> {
-    pub fn new(mut state: S) -> Self {
-        let last_state_root = state.finalise_root().expect("can't get state root");
+    pub fn new(state: S) -> Self {
         Self {
             state,
             journal: Journal::default(),
@@ -218,8 +234,9 @@ impl<S: State + CodeStore> StateDB<S> {
             dirty_account_count: Default::default(),
             dirty_data: Default::default(),
             dirty_scripts: Default::default(),
+            dirty_logs: Default::default(),
             state_tracker: None,
-            last_state_root,
+            last_state_root: H256::default(),
         }
     }
 
@@ -274,14 +291,38 @@ impl<S: State + CodeStore> StateDB<S> {
         Ok(())
     }
 
-    /// Return last state root
-    /// Invoke `calculate_root` will update this value
     pub fn last_state_root(&self) -> H256 {
         self.last_state_root
     }
 
+    pub(crate) fn is_dirty(&self) -> bool {
+        !self.journal.is_empty()
+            || !self.revisions.is_empty()
+            || self.dirty_account_count.is_some()
+            || !self.dirty_state.is_empty()
+            || !self.dirty_scripts.is_empty()
+            || !self.dirty_data.is_empty()
+            || !self.dirty_logs.is_empty()
+    }
+
+    /// clear journal and dirty
+    fn clear_journal_and_dirty(&mut self) {
+        // clear journal
+        self.journal.clear();
+        // clear revisions
+        self.revisions.clear();
+        // clear dirties
+        self.dirty_account_count = None;
+        self.dirty_state.clear();
+        self.dirty_scripts.clear();
+        self.dirty_data.clear();
+        self.dirty_logs.clear();
+    }
+}
+
+impl<S: State + CodeStore> JournalDB for StateDB<S> {
     /// create snapshot
-    pub fn snapshot(&mut self) -> usize {
+    fn snapshot(&mut self) -> usize {
         let id = self.next_revision_id;
         self.next_revision_id += 1;
         self.revisions.push_back(Revision {
@@ -292,12 +333,15 @@ impl<S: State + CodeStore> StateDB<S> {
     }
 
     /// revert to a snapshot
-    pub fn revert(&mut self, id: usize) -> Result<()> {
+    fn revert(&mut self, id: usize) -> Result<(), StateError> {
         // find revision
         let rev_index = self
             .revisions
             .binary_search_by_key(&id, |r| r.id)
-            .map_err(|_id| anyhow!("Invalid revision id"))?;
+            .map_err(|_id| {
+                log::error!("invalid revision: {}", id);
+                StateError::Store
+            })?;
         let rev = &self.revisions[rev_index];
 
         // replay to revert journal
@@ -310,9 +354,11 @@ impl<S: State + CodeStore> StateDB<S> {
         self.revisions.truncate(rev_index);
         Ok(())
     }
-
     /// write dirty state to DB
-    pub fn finalise(&mut self) -> Result<()> {
+    fn finalise(&mut self) -> Result<(), StateError> {
+        if !self.is_dirty() {
+            return Ok(());
+        }
         // write account count
         if let Some(count) = self.dirty_account_count {
             self.state.set_account_count(count)?;
@@ -330,42 +376,32 @@ impl<S: State + CodeStore> StateDB<S> {
             self.state.insert_data(*data_hash, data.to_owned());
         }
         // clear
-        self.clear_journal_and_dirty()
+        self.clear_journal_and_dirty();
+        // update last state root
+        self.last_state_root = self.calculate_root()?;
+        Ok(())
     }
 
-    #[cfg(test)]
-    pub(crate) fn is_dirty(&self) -> bool {
-        self.journal.len() != 0
-            || !self.revisions.is_empty()
-            || self.dirty_account_count.is_some()
-            || !self.dirty_state.is_empty()
-            || !self.dirty_scripts.is_empty()
-            || !self.dirty_data.is_empty()
+    fn append_log(&mut self, log: packed::LogItem) {
+        self.journal.push(JournalEntry::AppendLog {
+            index: self.dirty_logs.len(),
+        });
+        self.dirty_logs.push_back(log);
     }
 
-    /// clear journal and dirty
-    fn clear_journal_and_dirty(&mut self) -> Result<()> {
-        // clear journal
-        self.journal.clear();
-        // clear revisions
-        self.revisions.clear();
-        // clear dirties
-        self.dirty_account_count = None;
-        self.dirty_state.clear();
-        self.dirty_scripts.clear();
-        self.dirty_data.clear();
-        Ok(())
+    fn appended_logs(&self) -> &im::Vector<packed::LogItem> {
+        &self.dirty_logs
     }
 
-    pub fn set_state_tracker(&mut self, tracker: StateTracker) {
+    fn set_state_tracker(&mut self, tracker: StateTracker) {
         self.state_tracker = Some(tracker);
     }
 
-    pub fn state_tracker(&self) -> Option<&StateTracker> {
+    fn state_tracker(&self) -> Option<&StateTracker> {
         self.state_tracker.as_ref()
     }
 
-    pub fn take_state_tracker(&mut self) -> Option<StateTracker> {
+    fn take_state_tracker(&mut self) -> Option<StateTracker> {
         self.state_tracker.take()
     }
 }
@@ -408,15 +444,13 @@ impl<S: State + CodeStore> State for StateDB<S> {
         Ok(())
     }
 
-    /// Finalise in-memory dirty state and calculate root
-    fn finalise_root(&mut self) -> Result<H256, StateError> {
+    /// calculate root
+    fn calculate_root(&self) -> Result<H256, StateError> {
         // finalise dirty state
-        self.finalise().map_err(|err| {
-            log::error!("finalise error: {}", err);
-            StateError::Store
-        })?;
-        self.last_state_root = self.state.finalise_root()?;
-        Ok(self.last_state_root)
+        if self.is_dirty() {
+            return Err(StateError::Store);
+        }
+        self.state.calculate_root()
     }
 }
 
@@ -437,6 +471,13 @@ impl<S: CodeStore> CodeStore for StateDB<S> {
     }
 
     fn insert_data(&mut self, data_hash: H256, code: Bytes) {
+        if let Some(state_tracker) = self.state_tracker.as_ref() {
+            state_tracker
+                .write_data()
+                .lock()
+                .unwrap()
+                .insert(data_hash, code.clone());
+        }
         self.journal.push(JournalEntry::InsertData {
             data_hash,
             prev_exist: self.get_data(&data_hash).is_some(),
@@ -445,10 +486,21 @@ impl<S: CodeStore> CodeStore for StateDB<S> {
     }
 
     fn get_data(&self, data_hash: &H256) -> Option<Bytes> {
-        if let Some(data) = self.dirty_data.get(data_hash) {
-            return Some(data.to_owned());
+        let data = self
+            .dirty_data
+            .get(data_hash)
+            .cloned()
+            .or_else(|| self.state.get_data(data_hash));
+        if let Some(data) = data.as_ref() {
+            if let Some(state_tracker) = self.state_tracker.as_ref() {
+                state_tracker
+                    .read_data()
+                    .lock()
+                    .unwrap()
+                    .insert(*data_hash, data.clone());
+            }
         }
-        self.state.get_data(data_hash)
+        data
     }
 }
 
@@ -462,6 +514,7 @@ mod tests {
         snapshot::StoreSnapshot,
         state::{
             overlay::{mem_state::MemStateTree, mem_store::MemStore},
+            traits::JournalDB,
             MemStateDB,
         },
         Store,
@@ -550,7 +603,7 @@ mod tests {
         assert!(state.is_dirty());
 
         // clear journal and dirty state
-        state.clear_journal_and_dirty().unwrap();
+        state.clear_journal_and_dirty();
         assert!(!state.is_dirty());
         // the dirty state is cleared
         assert!(cmp_dirty_state(&mem_0, &state));
diff --git a/crates/store/src/state/traits.rs b/crates/store/src/state/traits.rs
index d955d15c4..bc2eb7c84 100644
--- a/crates/store/src/state/traits.rs
+++ b/crates/store/src/state/traits.rs
@@ -1,5 +1,19 @@
 use gw_common::smt::SMT;
+use gw_types::packed::LogItem;
+
+use super::state_db::StateTracker;
 
 pub trait SMTTree<S> {
     fn smt_tree(&self) -> SMT<S>;
 }
+
+pub trait JournalDB {
+    fn snapshot(&mut self) -> usize;
+    fn revert(&mut self, id: usize) -> Result<(), gw_common::error::Error>;
+    fn appended_logs(&self) -> &im::Vector<LogItem>;
+    fn append_log(&mut self, log: LogItem);
+    fn finalise(&mut self) -> Result<(), gw_common::error::Error>;
+    fn set_state_tracker(&mut self, tracker: StateTracker);
+    fn state_tracker(&self) -> Option<&StateTracker>;
+    fn take_state_tracker(&mut self) -> Option<StateTracker>;
+}
diff --git a/crates/store/src/tests/state_db.rs b/crates/store/src/tests/state_db.rs
index 0087f7bde..f1680d560 100644
--- a/crates/store/src/tests/state_db.rs
+++ b/crates/store/src/tests/state_db.rs
@@ -1,5 +1,5 @@
 use crate::{
-    state::{history::history_state::RWConfig, BlockStateDB},
+    state::{history::history_state::RWConfig, traits::JournalDB, BlockStateDB},
     traits::{chain_store::ChainStore, kv_store::KVStoreWrite},
     transaction::StoreTransaction,
     Store,
@@ -13,13 +13,14 @@ use gw_types::{
     prelude::{Builder, Entity, Pack, Unpack},
 };
 
-fn build_block(
-    state: &mut impl State,
+fn build_block<S: State + JournalDB>(
+    state: &mut S,
     block_number: u64,
     prev_txs_state_checkpoint: H256,
 ) -> L2Block {
+    state.finalise().unwrap();
     let post_state = AccountMerkleState::new_builder()
-        .merkle_root(state.finalise_root().unwrap().pack())
+        .merkle_root(state.calculate_root().unwrap().pack())
         .count(state.get_account_count().unwrap().pack())
         .build();
     L2Block::new_builder()
diff --git a/crates/tests/src/tests/chain.rs b/crates/tests/src/tests/chain.rs
index 4ad2d4344..5e54c9900 100644
--- a/crates/tests/src/tests/chain.rs
+++ b/crates/tests/src/tests/chain.rs
@@ -349,8 +349,8 @@ async fn test_layer1_fork() {
     // check account SMT, should be able to calculate account state root
     {
         let db = chain.store().begin_transaction();
-        let mut tree = BlockStateDB::from_store(&db, RWConfig::readonly()).unwrap();
-        let current_account_root = tree.finalise_root().unwrap();
+        let tree = BlockStateDB::from_store(&db, RWConfig::readonly()).unwrap();
+        let current_account_root = tree.calculate_root().unwrap();
         let expected_account_root: H256 = tip_block.raw().post_account().merkle_root().unpack();
         assert_eq!(
             current_account_root, expected_account_root,
@@ -501,8 +501,8 @@ async fn test_layer1_revert() {
     // check account SMT, should be able to calculate account state root
     {
         let db = chain.store().begin_transaction();
-        let mut tree = BlockStateDB::from_store(&db, RWConfig::readonly()).unwrap();
-        let current_account_root = tree.finalise_root().unwrap();
+        let tree = BlockStateDB::from_store(&db, RWConfig::readonly()).unwrap();
+        let current_account_root = tree.calculate_root().unwrap();
         let expected_account_root: H256 = tip_block.raw().post_account().merkle_root().unpack();
         assert_eq!(
             current_account_root, expected_account_root,
@@ -555,8 +555,8 @@ async fn test_layer1_revert() {
 
     {
         let db = chain.store().begin_transaction();
-        let mut tree = BlockStateDB::from_store(&db, RWConfig::readonly()).unwrap();
-        let current_account_root = tree.finalise_root().unwrap();
+        let tree = BlockStateDB::from_store(&db, RWConfig::readonly()).unwrap();
+        let current_account_root = tree.calculate_root().unwrap();
         let expected_account_root: H256 = tip_block.raw().post_account().merkle_root().unpack();
         assert_eq!(
             current_account_root, expected_account_root,
diff --git a/crates/tests/src/tests/mem_block_repackage.rs b/crates/tests/src/tests/mem_block_repackage.rs
index f9fbdb6f8..e81f0b799 100644
--- a/crates/tests/src/tests/mem_block_repackage.rs
+++ b/crates/tests/src/tests/mem_block_repackage.rs
@@ -57,11 +57,11 @@ async fn test_repackage_mem_block() {
 
     {
         let snap = chain.store().get_snapshot();
-        let mut state = MemStateDB::from_store(snap).unwrap();
+        let state = MemStateDB::from_store(snap).unwrap();
         let tip_block = chain.store().get_tip_block().unwrap();
 
         assert_eq!(
-            state.finalise_merkle_state().unwrap().as_slice(),
+            state.calculate_merkle_state().unwrap().as_slice(),
             tip_block.raw().post_account().as_slice()
         );
     }
diff --git a/crates/tx-filter/src/erc20_creator_allowlist.rs b/crates/tx-filter/src/erc20_creator_allowlist.rs
index 0b8f7631b..b3631ff8a 100644
--- a/crates/tx-filter/src/erc20_creator_allowlist.rs
+++ b/crates/tx-filter/src/erc20_creator_allowlist.rs
@@ -33,11 +33,7 @@ impl SUDTProxyAccountAllowlist {
             return true;
         }
 
-        if run_result.write.new_scripts.is_empty() {
-            return true;
-        }
-
-        for k in run_result.write.write_data.keys() {
+        for k in &run_result.write_data_hashes {
             debug!(
                 "allowlist: from_id: {:?}, code_hash: {:?}",
                 &from_id,
diff --git a/crates/tx-filter/src/polyjuice_contract_creator_allowlist.rs b/crates/tx-filter/src/polyjuice_contract_creator_allowlist.rs
index c3941ff67..c9ebb073c 100644
--- a/crates/tx-filter/src/polyjuice_contract_creator_allowlist.rs
+++ b/crates/tx-filter/src/polyjuice_contract_creator_allowlist.rs
@@ -162,7 +162,7 @@ mod tests {
             self.tree.update(key, value)?;
             Ok(())
         }
-        fn finalise_root(&mut self) -> Result<H256, Error> {
+        fn calculate_root(&self) -> Result<H256, Error> {
             let root = *self.tree.root();
             Ok(root)
         }
diff --git a/crates/types/src/offchain/extension.rs b/crates/types/src/offchain/extension.rs
index 7af55d482..7dfdb420b 100644
--- a/crates/types/src/offchain/extension.rs
+++ b/crates/types/src/offchain/extension.rs
@@ -40,13 +40,12 @@ impl TxReceipt {
             .post_state(post_state)
             .read_data_hashes(
                 run_result
-                    .read_data
+                    .read_data_hashes
                     .into_iter()
-                    .map(|(hash, _)| hash.pack())
                     .collect::<Vec<_>>()
                     .pack(),
             )
-            .logs(run_result.write.logs.pack())
+            .logs(run_result.logs.pack())
             .build()
     }
 }
diff --git a/crates/types/src/offchain/generator.rs b/crates/types/src/offchain/generator.rs
new file mode 100644
index 000000000..876ce3e92
--- /dev/null
+++ b/crates/types/src/offchain/generator.rs
@@ -0,0 +1,11 @@
+#[derive(Debug, Clone, Default, PartialEq, Eq)]
+pub struct CycleMeter {
+    pub execution: u64,
+    pub r#virtual: u64,
+}
+
+impl CycleMeter {
+    pub fn total(&self) -> u64 {
+        self.execution.saturating_add(self.r#virtual)
+    }
+}
diff --git a/crates/types/src/offchain/mod.rs b/crates/types/src/offchain/mod.rs
index 60891b3bf..39aee9cb5 100644
--- a/crates/types/src/offchain/mod.rs
+++ b/crates/types/src/offchain/mod.rs
@@ -1,6 +1,7 @@
 mod error_receipt;
 mod exported_block;
 mod extension;
+mod generator;
 mod mem_block;
 mod pool;
 mod rollup_context;
@@ -11,6 +12,7 @@ mod store;
 pub use error_receipt::*;
 pub use exported_block::*;
 pub use extension::global_state_from_slice;
+pub use generator::CycleMeter;
 pub use mem_block::*;
 pub use pool::*;
 pub use rollup_context::*;
diff --git a/crates/types/src/offchain/run_result.rs b/crates/types/src/offchain/run_result.rs
index a7cbc2eb9..a80beb79f 100644
--- a/crates/types/src/offchain/run_result.rs
+++ b/crates/types/src/offchain/run_result.rs
@@ -2,7 +2,9 @@ use crate::bytes::Bytes;
 use crate::packed::{CellOutput, LogItem, Script};
 use crate::prelude::*;
 use sparse_merkle_tree::H256;
-use std::collections::{HashMap, HashSet};
+use std::collections::HashSet;
+
+use super::CycleMeter;
 
 #[derive(Debug, Clone, Hash, PartialEq, Eq)]
 pub struct RecoverAccount {
@@ -10,15 +12,6 @@ pub struct RecoverAccount {
     pub signature: Vec<u8>,
     pub lock_script: Script,
 }
-#[derive(Debug, Clone, Default)]
-pub struct RunResultWriteState {
-    pub write_values: HashMap<H256, H256>,
-    pub account_count: Option<u32>,
-    pub new_scripts: HashMap<H256, Script>,
-    pub write_data: HashMap<H256, Bytes>,
-    // log data
-    pub logs: Vec<LogItem>,
-}
 
 #[derive(Debug, Clone, Default, PartialEq, Eq)]
 pub struct RunResultCycles {
@@ -34,22 +27,12 @@ impl RunResultCycles {
 
 #[derive(Debug, Clone, Default)]
 pub struct RunResult {
-    pub read_values: HashMap<H256, H256>,
     pub return_data: Bytes,
-    pub recover_accounts: HashSet<RecoverAccount>,
-    pub get_scripts: HashMap<H256, Script>,
-    // data hash -> data full size
-    pub read_data: HashMap<H256, Bytes>,
+    pub logs: Vec<LogItem>,
     pub exit_code: i8,
-    pub write: RunResultWriteState,
-    pub cycles: RunResultCycles,
-}
-
-impl RunResult {
-    // clear all write fields
-    pub fn revert_write(&mut self) {
-        self.write = Default::default();
-    }
+    pub cycles: CycleMeter,
+    pub read_data_hashes: HashSet<H256>,
+    pub write_data_hashes: HashSet<H256>,
 }
 
 impl CellOutput {

From ae108cc627b65fa6656bc3296c5e50b5dc2a5133 Mon Sep 17 00:00:00 2001
From: jjy <jjyruby@gmail.com>
Date: Tue, 1 Nov 2022 18:25:39 +0800
Subject: [PATCH 04/10] feat: new syscalls snapshot and revert

---
 crates/config/src/config.rs                   |  4 +++
 crates/generator/src/syscalls/mod.rs          | 32 ++++++++++++++++---
 crates/generator/src/tests/genesis.rs         |  2 +-
 .../block_max_cycles_limit.rs                 |  2 ++
 4 files changed, 34 insertions(+), 6 deletions(-)

diff --git a/crates/config/src/config.rs b/crates/config/src/config.rs
index c656ac348..61e90d13e 100644
--- a/crates/config/src/config.rs
+++ b/crates/config/src/config.rs
@@ -573,6 +573,8 @@ pub struct SyscallCyclesConfig {
     pub sys_bn_mul_cycles: u64,
     pub sys_bn_fixed_pairing_cycles: u64,
     pub sys_bn_per_pairing_cycles: u64,
+    pub sys_snapshot_cycles: u64,
+    pub sys_revert_cycles: u64,
 }
 
 impl SyscallCyclesConfig {
@@ -595,6 +597,8 @@ impl SyscallCyclesConfig {
             sys_bn_mul_cycles: 18_000,
             sys_bn_fixed_pairing_cycles: 135_000,
             sys_bn_per_pairing_cycles: 102_000,
+            sys_snapshot_cycles: 2000,
+            sys_revert_cycles: 2000,
         }
     }
 }
diff --git a/crates/generator/src/syscalls/mod.rs b/crates/generator/src/syscalls/mod.rs
index f70a306de..cff54cda4 100644
--- a/crates/generator/src/syscalls/mod.rs
+++ b/crates/generator/src/syscalls/mod.rs
@@ -64,6 +64,9 @@ const SYS_RECOVER_ACCOUNT: u64 = 3503;
 const SYS_BN_ADD: u64 = 3601;
 const SYS_BN_MUL: u64 = 3602;
 const SYS_BN_PAIRING: u64 = 3603;
+/* Syscall state revert */
+const SYS_SNAPSHOT: u64 = 3701;
+const SYS_REVERT: u64 = 3702;
 /* CKB compatible syscalls */
 const DEBUG_PRINT_SYSCALL_NUMBER: u64 = 2177;
 
@@ -592,14 +595,14 @@ impl<'a, 'b, S: State + CodeStore + JournalDB, C: ChainView, Mac: SupportMachine
                         // Subtract additional cycles per pairing
                         let additional_cycles =
                             k * cycles_pool.syscall_config().sys_bn_per_pairing_cycles;
-                        self.result.cycles.r#virtual = self
-                            .result
-                            .cycles
+                        self.context.cycle_meter.r#virtual = self
+                            .context
+                            .cycle_meter
                             .r#virtual
                             .saturating_add(additional_cycles);
                         let execution_and_virtual = machine
                             .cycles()
-                            .saturating_add(self.result.cycles.r#virtual);
+                            .saturating_add(self.context.cycle_meter.r#virtual);
                         if cycles_pool.consume_cycles(additional_cycles).is_none()
                             || execution_and_virtual > cycles_pool.limit()
                         {
@@ -616,7 +619,24 @@ impl<'a, 'b, S: State + CodeStore + JournalDB, C: ChainView, Mac: SupportMachine
                     VMError::Unexpected(err_msg)
                 })?;
                 store_data(machine, output.as_slice())?;
-
+                machine.set_register(A0, Mac::REG::from_u8(SUCCESS));
+                Ok(true)
+            }
+            SYS_SNAPSHOT => {
+                let snapshot_addr = machine.registers()[A0].clone();
+                // create snapshot
+                let snapshot_id = self.state.snapshot() as u32;
+                machine
+                    .memory_mut()
+                    .store32(&snapshot_addr, &Mac::REG::from_u32(snapshot_id))?;
+                machine.set_register(A0, Mac::REG::from_u8(SUCCESS));
+                Ok(true)
+            }
+            SYS_REVERT => {
+                let snapshot_id = machine.registers()[A0].to_u32();
+                self.state
+                    .revert(snapshot_id as usize)
+                    .map_err(|err| VMError::Unexpected(format!("revert: {}", err)))?;
                 machine.set_register(A0, Mac::REG::from_u8(SUCCESS));
                 Ok(true)
             }
@@ -694,6 +714,8 @@ impl<'a, 'b, S: State, C: ChainView> L2Syscalls<'a, 'b, S, C> {
             SYS_BN_ADD => cycles_config.sys_bn_add_cycles,
             SYS_BN_MUL => cycles_config.sys_bn_mul_cycles,
             SYS_BN_PAIRING => cycles_config.sys_bn_fixed_pairing_cycles,
+            SYS_SNAPSHOT => cycles_config.sys_snapshot_cycles,
+            SYS_REVERT => cycles_config.sys_revert_cycles,
             _ => 0,
         }
     }
diff --git a/crates/generator/src/tests/genesis.rs b/crates/generator/src/tests/genesis.rs
index f87b9dc79..28eaab6ff 100644
--- a/crates/generator/src/tests/genesis.rs
+++ b/crates/generator/src/tests/genesis.rs
@@ -36,7 +36,7 @@ fn test_init_genesis() {
     let db = &store.begin_transaction();
     // check init values
     assert_ne!(db.get_block_smt_root().unwrap(), H256::zero());
-    let mut tree = BlockStateDB::from_store(db, RWConfig::readonly()).unwrap();
+    let tree = BlockStateDB::from_store(db, RWConfig::readonly()).unwrap();
     assert!(tree.get_account_count().unwrap() > 0);
 
     // check prev txs state
diff --git a/crates/tests/src/tests/rpc_server/submit_l2transaction/block_max_cycles_limit.rs b/crates/tests/src/tests/rpc_server/submit_l2transaction/block_max_cycles_limit.rs
index de9a071e3..9114e6ea9 100644
--- a/crates/tests/src/tests/rpc_server/submit_l2transaction/block_max_cycles_limit.rs
+++ b/crates/tests/src/tests/rpc_server/submit_l2transaction/block_max_cycles_limit.rs
@@ -369,6 +369,8 @@ async fn test_block_max_cycles_limit() {
                 sys_bn_mul_cycles: MAX_CYCLES_LIMIT,
                 sys_bn_fixed_pairing_cycles: MAX_CYCLES_LIMIT,
                 sys_bn_per_pairing_cycles: MAX_CYCLES_LIMIT,
+                sys_revert_cycles: MAX_CYCLES_LIMIT,
+                sys_snapshot_cycles: MAX_CYCLES_LIMIT,
             },
             ..Default::default()
         },

From c74c8de40f03a1307a9617721aebeee4b25eb0c6 Mon Sep 17 00:00:00 2001
From: jjy <jjyruby@gmail.com>
Date: Tue, 1 Nov 2022 22:11:06 +0800
Subject: [PATCH 05/10] chore: fix cargo clippy warning

---
 .../benches/benches/benchmarks/dummy_state.rs | 56 -------------------
 crates/benches/benches/benchmarks/mod.rs      |  1 -
 crates/benches/benches/benchmarks/smt.rs      | 13 ++---
 crates/benches/benches/benchmarks/sudt.rs     | 30 +++++++---
 crates/store/src/tests/state_db.rs            |  2 +-
 crates/tests/src/testing_tool/chain.rs        |  2 +-
 crates/tests/src/tests/meta_contract_args.rs  |  2 +-
 .../src/tests/polyjuice_sender_recover.rs     |  2 +-
 .../tests/rpc_server/execute_l2transaction.rs | 12 ++--
 .../block_max_cycles_limit.rs                 |  2 +-
 .../rpc_server/execute_raw_l2transaction.rs   |  8 +--
 .../block_max_cycles_limit.rs                 |  4 +-
 .../tests/rpc_server/submit_l2transaction.rs  | 16 +++---
 13 files changed, 54 insertions(+), 96 deletions(-)
 delete mode 100644 crates/benches/benches/benchmarks/dummy_state.rs

diff --git a/crates/benches/benches/benchmarks/dummy_state.rs b/crates/benches/benches/benchmarks/dummy_state.rs
deleted file mode 100644
index 902bb9ee2..000000000
--- a/crates/benches/benches/benchmarks/dummy_state.rs
+++ /dev/null
@@ -1,56 +0,0 @@
-use gw_common::{
-    error::Error,
-    smt::{default_store::DefaultStore, H256, SMT},
-    state::State,
-};
-use gw_traits::CodeStore;
-use gw_types::{bytes::Bytes, packed::Script};
-use std::collections::HashMap;
-
-#[derive(Default)]
-pub struct DummyState {
-    tree: SMT<DefaultStore<H256>>,
-    account_count: u32,
-    scripts: HashMap<H256, Script>,
-    codes: HashMap<H256, Bytes>,
-}
-
-impl State for DummyState {
-    fn get_raw(&self, key: &H256) -> Result<H256, Error> {
-        let v = self.tree.get(key)?;
-        Ok(v)
-    }
-    fn update_raw(&mut self, key: H256, value: H256) -> Result<(), Error> {
-        self.tree.update(key, value)?;
-        Ok(())
-    }
-    fn finalise(&mut self) -> Result<(), Error> {
-        Err(Error::Store)
-    }
-    fn calculate_root(&self) -> Result<H256, Error> {
-        let root = *self.tree.root();
-        Ok(root)
-    }
-    fn get_account_count(&self) -> Result<u32, Error> {
-        Ok(self.account_count)
-    }
-    fn set_account_count(&mut self, count: u32) -> Result<(), Error> {
-        self.account_count = count;
-        Ok(())
-    }
-}
-
-impl CodeStore for DummyState {
-    fn insert_script(&mut self, script_hash: H256, script: Script) {
-        self.scripts.insert(script_hash, script);
-    }
-    fn get_script(&self, script_hash: &H256) -> Option<Script> {
-        self.scripts.get(script_hash).cloned()
-    }
-    fn insert_data(&mut self, data_hash: H256, code: Bytes) {
-        self.codes.insert(data_hash, code);
-    }
-    fn get_data(&self, script_hash: &H256) -> Option<Bytes> {
-        self.codes.get(script_hash).cloned()
-    }
-}
diff --git a/crates/benches/benches/benchmarks/mod.rs b/crates/benches/benches/benchmarks/mod.rs
index 8b1adca01..4d0e03bcc 100644
--- a/crates/benches/benches/benchmarks/mod.rs
+++ b/crates/benches/benches/benchmarks/mod.rs
@@ -1,4 +1,3 @@
-mod dummy_state;
 pub mod fee_queue;
 pub mod init_db;
 pub mod smt;
diff --git a/crates/benches/benches/benchmarks/smt.rs b/crates/benches/benches/benchmarks/smt.rs
index 32059c697..d55e54c48 100644
--- a/crates/benches/benches/benchmarks/smt.rs
+++ b/crates/benches/benches/benchmarks/smt.rs
@@ -1,5 +1,3 @@
-use std::sync::Arc;
-
 use criterion::{criterion_group, BenchmarkId, Criterion, Throughput};
 use gw_common::{
     blake2b::new_blake2b,
@@ -23,6 +21,7 @@ use gw_store::{
     state::{
         history::history_state::{HistoryState, RWConfig},
         state_db::StateDB,
+        traits::JournalDB,
         MemStateDB,
     },
     traits::chain_store::ChainStore,
@@ -257,11 +256,10 @@ impl BenchExecutionEnvironment {
                 .args(args.as_bytes().pack())
                 .build();
 
-            let run_result = self
-                .generator
+            self.generator
                 .execute_transaction(
                     &self.chain,
-                    &state,
+                    &mut state,
                     &block_info,
                     &raw_tx,
                     L2TX_MAX_CYCLES,
@@ -269,7 +267,7 @@ impl BenchExecutionEnvironment {
                 )
                 .unwrap();
 
-            state.apply_run_result(&run_result.write).unwrap();
+            state.finalise().unwrap();
 
             from_id += 1;
             if from_id > end_account_id {
@@ -336,6 +334,7 @@ impl BenchExecutionEnvironment {
         };
 
         Self::generate_accounts(&mut state, accounts + 1); // Plus block producer
+        state.finalise().unwrap();
 
         let (genesis, global_state) = {
             let prev_state_checkpoint: [u8; 32] =
@@ -346,7 +345,7 @@ impl BenchExecutionEnvironment {
 
             // calculate post state
             let post_account = {
-                let root = state.finalise_root().unwrap();
+                let root = state.calculate_root().unwrap();
                 let count = state.get_account_count().unwrap();
                 AccountMerkleState::new_builder()
                     .merkle_root(root.pack())
diff --git a/crates/benches/benches/benchmarks/sudt.rs b/crates/benches/benches/benchmarks/sudt.rs
index a8f3b3877..2ca6a0a66 100644
--- a/crates/benches/benches/benchmarks/sudt.rs
+++ b/crates/benches/benches/benchmarks/sudt.rs
@@ -1,13 +1,23 @@
-use super::dummy_state::DummyState;
 use criterion::*;
 use gw_common::{
-    builtins::ETH_REGISTRY_ACCOUNT_ID, registry_address::RegistryAddress, state::State, H256,
+    builtins::ETH_REGISTRY_ACCOUNT_ID, registry_address::RegistryAddress, smt::SMT, state::State,
+    H256,
 };
 use gw_config::{BackendConfig, BackendSwitchConfig};
 use gw_generator::{
     account_lock_manage::AccountLockManage, backend_manage::BackendManage,
     constants::L2TX_MAX_CYCLES, error::TransactionError, traits::StateExt, Generator,
 };
+use gw_store::{
+    smt::smt_store::SMTStateStore,
+    snapshot::StoreSnapshot,
+    state::{
+        overlay::{mem_state::MemStateTree, mem_store::MemStore},
+        traits::JournalDB,
+        MemStateDB,
+    },
+    Store,
+};
 use gw_traits::{ChainView, CodeStore};
 use gw_types::{
     bytes::Bytes,
@@ -62,6 +72,12 @@ impl ChainView for DummyChainStore {
     }
 }
 
+fn new_state(store: StoreSnapshot) -> MemStateDB {
+    let smt = SMT::new(H256::zero(), SMTStateStore::new(MemStore::new(store)));
+    let inner = MemStateTree::new(smt, 0);
+    MemStateDB::new(inner)
+}
+
 fn new_block_info(block_producer: &RegistryAddress, number: u64, timestamp: u64) -> BlockInfo {
     BlockInfo::new_builder()
         .block_producer(Bytes::from(block_producer.to_bytes()).pack())
@@ -70,7 +86,7 @@ fn new_block_info(block_producer: &RegistryAddress, number: u64, timestamp: u64)
         .build()
 }
 
-fn run_contract_get_result<S: State + CodeStore>(
+fn run_contract_get_result<S: State + CodeStore + JournalDB>(
     rollup_config: &RollupConfig,
     tree: &mut S,
     from_id: u32,
@@ -104,12 +120,11 @@ fn run_contract_get_result<S: State + CodeStore>(
         L2TX_MAX_CYCLES,
         None,
     )?;
-    tree.apply_run_result(&run_result.write)
-        .expect("update state");
+    tree.finalise()?;
     Ok(run_result)
 }
 
-fn run_contract<S: State + CodeStore>(
+fn run_contract<S: State + CodeStore + JournalDB>(
     rollup_config: &RollupConfig,
     tree: &mut S,
     from_id: u32,
@@ -128,7 +143,8 @@ pub fn bench(c: &mut Criterion) {
     group.bench_function("sudt", move |b| {
         b.iter_batched(
             || {
-                let mut tree = DummyState::default();
+                let db = Store::open_tmp().unwrap();
+                let mut tree = new_state(db.get_snapshot());
 
                 let always_success_lock_hash = [255u8; 32];
                 let rollup_config = RollupConfig::new_builder()
diff --git a/crates/store/src/tests/state_db.rs b/crates/store/src/tests/state_db.rs
index f1680d560..35c71f8d4 100644
--- a/crates/store/src/tests/state_db.rs
+++ b/crates/store/src/tests/state_db.rs
@@ -132,7 +132,7 @@ fn test_state_with_version() {
         state
             .update_raw(H256::from_u32(5), H256::from_u32(25))
             .unwrap();
-        commit_block(&db, build_block(&mut state, 2, prev_txs_state_checkpoint));
+        commit_block(db, build_block(&mut state, 2, prev_txs_state_checkpoint));
         db.set_last_confirmed_block_number_hash(
             &NumberHash::new_builder()
                 .number(2.pack())
diff --git a/crates/tests/src/testing_tool/chain.rs b/crates/tests/src/testing_tool/chain.rs
index 0dc09c2d5..1a50278cd 100644
--- a/crates/tests/src/testing_tool/chain.rs
+++ b/crates/tests/src/testing_tool/chain.rs
@@ -642,7 +642,7 @@ pub async fn construct_block_with_timestamp(
         reverted_block_root,
         block_param,
     };
-    produce_block(&db, generator, param).map(|mut r| {
+    produce_block(db, generator, param).map(|mut r| {
         r.remaining_capacity = remaining_capacity;
         r
     })
diff --git a/crates/tests/src/tests/meta_contract_args.rs b/crates/tests/src/tests/meta_contract_args.rs
index 2902a60db..8a7722b7e 100644
--- a/crates/tests/src/tests/meta_contract_args.rs
+++ b/crates/tests/src/tests/meta_contract_args.rs
@@ -73,7 +73,7 @@ async fn test_backward_compatibility() {
         .signature(sign.pack())
         .build();
 
-    mem_pool_state.store_state_db(state.into());
+    mem_pool_state.store_state_db(state);
     {
         let mut mem_pool = chain.mem_pool().await;
         mem_pool.push_transaction(create_user_tx).unwrap();
diff --git a/crates/tests/src/tests/polyjuice_sender_recover.rs b/crates/tests/src/tests/polyjuice_sender_recover.rs
index 5456cc9e8..44b71c48b 100644
--- a/crates/tests/src/tests/polyjuice_sender_recover.rs
+++ b/crates/tests/src/tests/polyjuice_sender_recover.rs
@@ -87,7 +87,7 @@ async fn test_eth_account_creator() {
         .build_batch_create_tx(&state, recovered_account_scripts)
         .unwrap();
 
-    mem_pool_state.store_state_db(state.into());
+    mem_pool_state.store_state_db(state);
     {
         let mut mem_pool = chain.mem_pool().await;
         mem_pool.push_transaction(batch_create_tx).unwrap();
diff --git a/crates/tests/src/tests/rpc_server/execute_l2transaction.rs b/crates/tests/src/tests/rpc_server/execute_l2transaction.rs
index 4d51cb668..799219884 100644
--- a/crates/tests/src/tests/rpc_server/execute_l2transaction.rs
+++ b/crates/tests/src/tests/rpc_server/execute_l2transaction.rs
@@ -58,7 +58,7 @@ async fn test_polyjuice_erc20_tx() {
         .build();
     let deploy_tx = test_wallet.sign_polyjuice_tx(&state, raw_tx).unwrap();
 
-    mem_pool_state.store_state_db(state.into());
+    mem_pool_state.store_state_db(state);
     let run_result = rpc_server.execute_l2transaction(&deploy_tx).await.unwrap();
 
     let logs = run_result.logs.into_iter().map(Into::into);
@@ -111,7 +111,7 @@ async fn test_polyjuice_tx_from_id_zero() {
     let deploy_tx = deployer_wallet.sign_polyjuice_tx(&state, raw_tx).unwrap();
     let deploy_tx_hash: H256 = deploy_tx.hash().into();
 
-    mem_pool_state.store_state_db(state.into());
+    mem_pool_state.store_state_db(state);
     {
         let mut mem_pool = chain.mem_pool().await;
         mem_pool.push_transaction(deploy_tx).unwrap();
@@ -159,7 +159,7 @@ async fn test_polyjuice_tx_from_id_zero() {
         .build();
     let balance_tx = test_wallet.sign_polyjuice_tx(&state, raw_tx).unwrap();
 
-    mem_pool_state.store_state_db(state.into());
+    mem_pool_state.store_state_db(state);
     let run_result = rpc_server.execute_l2transaction(&balance_tx).await.unwrap();
 
     assert_eq!(
@@ -209,7 +209,7 @@ async fn test_invalid_polyjuice_tx_from_id_zero() {
         .unwrap();
     let deploy_tx_hash: H256 = deploy_tx.hash().into();
 
-    mem_pool_state.store_state_db(state.into());
+    mem_pool_state.store_state_db(state);
     {
         let mut mem_pool = chain.mem_pool().await;
         mem_pool.push_transaction(deploy_tx).unwrap();
@@ -300,7 +300,7 @@ async fn test_invalid_polyjuice_tx_from_id_zero() {
 
     let balance = 100u32.into();
     test_wallet.mint_ckb_sudt(&mut state, balance).unwrap();
-    mem_pool_state.store_state_db(state.into());
+    mem_pool_state.store_state_db(state);
 
     let err = rpc_server
         .execute_l2transaction(&balance_tx)
@@ -316,7 +316,7 @@ async fn test_invalid_polyjuice_tx_from_id_zero() {
     state
         .mapping_registry_address_to_script_hash(test_wallet.reg_address().to_owned(), H256::one())
         .unwrap();
-    mem_pool_state.store_state_db(state.into());
+    mem_pool_state.store_state_db(state);
 
     let err = rpc_server
         .execute_l2transaction(&balance_tx)
diff --git a/crates/tests/src/tests/rpc_server/execute_l2transaction/block_max_cycles_limit.rs b/crates/tests/src/tests/rpc_server/execute_l2transaction/block_max_cycles_limit.rs
index eba6ac62b..6055a23a1 100644
--- a/crates/tests/src/tests/rpc_server/execute_l2transaction/block_max_cycles_limit.rs
+++ b/crates/tests/src/tests/rpc_server/execute_l2transaction/block_max_cycles_limit.rs
@@ -120,7 +120,7 @@ async fn test_block_max_cycles_limit() {
         .build();
     let deploy_tx = test_wallet.sign_polyjuice_tx(&state, raw_tx).unwrap();
 
-    mem_pool_state.store_state_db(state.into());
+    mem_pool_state.store_state_db(state);
     let err = rpc_server
         .execute_l2transaction(&deploy_tx)
         .await
diff --git a/crates/tests/src/tests/rpc_server/execute_raw_l2transaction.rs b/crates/tests/src/tests/rpc_server/execute_raw_l2transaction.rs
index 5dbaf6a8f..a399e24dd 100644
--- a/crates/tests/src/tests/rpc_server/execute_raw_l2transaction.rs
+++ b/crates/tests/src/tests/rpc_server/execute_raw_l2transaction.rs
@@ -65,7 +65,7 @@ async fn test_polyjuice_erc20_tx() {
         .build();
 
     let reg_addr_bytes = test_wallet.reg_address().to_bytes().into();
-    mem_pool_state.store_state_db(state.into());
+    mem_pool_state.store_state_db(state);
 
     let run_result = rpc_server
         .execute_raw_l2transaction(&raw_tx, None, Some(reg_addr_bytes))
@@ -122,7 +122,7 @@ async fn test_polyjuice_tx_from_id_zero() {
     let deploy_tx = deployer_wallet.sign_polyjuice_tx(&state, raw_tx).unwrap();
     let deploy_tx_hash: H256 = deploy_tx.hash().into();
 
-    mem_pool_state.store_state_db(state.into());
+    mem_pool_state.store_state_db(state);
     {
         let mut mem_pool = chain.mem_pool().await;
         mem_pool.push_transaction(deploy_tx).unwrap();
@@ -162,7 +162,7 @@ async fn test_polyjuice_tx_from_id_zero() {
         .mint_sudt(&mut state, CKB_SUDT_ACCOUNT_ID, test_balance)
         .unwrap();
 
-    mem_pool_state.store_state_db(state.into());
+    mem_pool_state.store_state_db(state);
     let state = mem_pool_state.load_state_db();
 
     let erc20_contract_account_id = system_log.contract_account_id(&state).unwrap();
@@ -486,7 +486,7 @@ async fn test_invalid_registry_address() {
     let deploy_tx = deployer_wallet.sign_polyjuice_tx(&state, raw_tx).unwrap();
     let deploy_tx_hash: H256 = deploy_tx.hash().into();
 
-    mem_pool_state.store_state_db(state.into());
+    mem_pool_state.store_state_db(state);
     {
         let mut mem_pool = chain.mem_pool().await;
         mem_pool.push_transaction(deploy_tx).unwrap();
diff --git a/crates/tests/src/tests/rpc_server/execute_raw_l2transaction/block_max_cycles_limit.rs b/crates/tests/src/tests/rpc_server/execute_raw_l2transaction/block_max_cycles_limit.rs
index 031b2ee10..8208f592d 100644
--- a/crates/tests/src/tests/rpc_server/execute_raw_l2transaction/block_max_cycles_limit.rs
+++ b/crates/tests/src/tests/rpc_server/execute_raw_l2transaction/block_max_cycles_limit.rs
@@ -70,7 +70,7 @@ async fn test_block_max_cycles_limit() {
         .build();
     let reg_addr_bytes = test_wallet.reg_address().to_bytes().into();
 
-    mem_pool_state.store_state_db(state.into());
+    mem_pool_state.store_state_db(state);
     let run_result = rpc_server
         .execute_raw_l2transaction(&raw_tx, None, Some(reg_addr_bytes))
         .await
@@ -123,7 +123,7 @@ async fn test_block_max_cycles_limit() {
         .build();
     let reg_addr_bytes = test_wallet.reg_address().to_bytes().into();
 
-    mem_pool_state.store_state_db(state.into());
+    mem_pool_state.store_state_db(state);
     let err = rpc_server
         .execute_raw_l2transaction(&raw_tx, None, Some(reg_addr_bytes))
         .await
diff --git a/crates/tests/src/tests/rpc_server/submit_l2transaction.rs b/crates/tests/src/tests/rpc_server/submit_l2transaction.rs
index ec294d766..a5ec9081a 100644
--- a/crates/tests/src/tests/rpc_server/submit_l2transaction.rs
+++ b/crates/tests/src/tests/rpc_server/submit_l2transaction.rs
@@ -52,7 +52,7 @@ async fn test_polyjuice_erc20_tx() {
         .build();
     let deploy_tx = creator_wallet.sign_polyjuice_tx(&state, raw_tx).unwrap();
 
-    mem_pool_state.store_state_db(state.into());
+    mem_pool_state.store_state_db(state);
     let deploy_tx_hash = rpc_server
         .submit_l2transaction(&deploy_tx)
         .await
@@ -141,7 +141,7 @@ async fn test_in_queue_query_with_signature_hash() {
     };
     let deploy_tx = test_wallet.sign_polyjuice_tx(&state, raw_tx).unwrap();
 
-    mem_pool_state.store_state_db(state.into());
+    mem_pool_state.store_state_db(state);
     let signature_hash = {
         let mut hasher = new_blake2b();
         let sig: Bytes = deploy_tx.signature().unpack();
@@ -209,7 +209,7 @@ async fn test_polyjuice_tx_from_id_zero() {
     };
     let deploy_tx = test_wallet.sign_polyjuice_tx(&state, raw_tx).unwrap();
 
-    mem_pool_state.store_state_db(state.into());
+    mem_pool_state.store_state_db(state);
     rpc_server.submit_l2transaction(&deploy_tx).await.unwrap();
     wait_tx_committed(&chain, &deploy_tx_hash, Duration::from_secs(30))
         .await
@@ -271,7 +271,7 @@ async fn test_polyjuice_tx_from_id_zero() {
         raw.hash().into()
     };
     let deploy_tx = test_wallet.sign_polyjuice_tx(&state, raw_tx).unwrap();
-    mem_pool_state.store_state_db(state.into());
+    mem_pool_state.store_state_db(state);
 
     rpc_server.submit_l2transaction(&deploy_tx).await.unwrap();
     wait_tx_committed(&chain, &deploy_tx_hash, Duration::from_secs(30))
@@ -341,7 +341,7 @@ async fn test_invalid_polyjuice_tx_from_id_zero() {
         .sign_polyjuice_tx(&state, raw_tx.clone())
         .unwrap();
 
-    mem_pool_state.store_state_db(state.into());
+    mem_pool_state.store_state_db(state);
     let err = rpc_server_no_creator
         .submit_l2transaction(&deploy_tx)
         .await
@@ -427,7 +427,7 @@ async fn test_invalid_polyjuice_tx_from_id_zero() {
     let insufficient_balance_deploy_tx = test_wallet
         .sign_polyjuice_tx(&state, raw_tx.clone())
         .unwrap();
-    mem_pool_state.store_state_db(state.into());
+    mem_pool_state.store_state_db(state);
 
     rpc_server
         .submit_l2transaction(&insufficient_balance_deploy_tx)
@@ -445,7 +445,7 @@ async fn test_invalid_polyjuice_tx_from_id_zero() {
         .unwrap();
 
     let different_script_deploy_tx = test_wallet.sign_polyjuice_tx(&state, raw_tx).unwrap();
-    mem_pool_state.store_state_db(state.into());
+    mem_pool_state.store_state_db(state);
 
     rpc_server
         .submit_l2transaction(&different_script_deploy_tx)
@@ -471,7 +471,7 @@ async fn test_invalid_polyjuice_tx_from_id_zero() {
         .build();
     let bad_deploy_tx = test_wallet.sign_polyjuice_tx(&state, raw_tx).unwrap();
 
-    mem_pool_state.store_state_db(state.into());
+    mem_pool_state.store_state_db(state);
     let err = rpc_server
         .submit_l2transaction(&bad_deploy_tx)
         .await

From c0c5c27567886fe64edadca9b7d32024cd3ea2ab Mon Sep 17 00:00:00 2001
From: jjy <jjyruby@gmail.com>
Date: Wed, 2 Nov 2022 12:17:48 +0800
Subject: [PATCH 06/10] fix: remove duplicated call

---
 crates/store/src/state/overlay/mem_state.rs | 10 ----------
 1 file changed, 10 deletions(-)

diff --git a/crates/store/src/state/overlay/mem_state.rs b/crates/store/src/state/overlay/mem_state.rs
index a7658f133..0693a0bb6 100644
--- a/crates/store/src/state/overlay/mem_state.rs
+++ b/crates/store/src/state/overlay/mem_state.rs
@@ -93,11 +93,6 @@ impl CodeStore for MemStateTree {
         self.db()
             .inner_store()
             .get(COLUMN_SCRIPT, script_hash.as_slice())
-            .or_else(|| {
-                self.db()
-                    .inner_store()
-                    .get(COLUMN_SCRIPT, script_hash.as_slice())
-            })
             .map(|slice| from_box_should_be_ok!(packed::ScriptReader, slice))
     }
 
@@ -112,11 +107,6 @@ impl CodeStore for MemStateTree {
         self.db()
             .inner_store()
             .get(COLUMN_DATA, data_hash.as_slice())
-            .or_else(|| {
-                self.db()
-                    .inner_store()
-                    .get(COLUMN_DATA, data_hash.as_slice())
-            })
             .map(|slice| Bytes::from(slice.to_vec()))
     }
 }

From e678479f0d2892560daa75a59cb1fb61bfaf69c9 Mon Sep 17 00:00:00 2001
From: jjy <jjyruby@gmail.com>
Date: Wed, 2 Nov 2022 12:25:48 +0800
Subject: [PATCH 07/10] refactor: remove DB access when generate Journal

---
 crates/store/src/state/state_db.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/crates/store/src/state/state_db.rs b/crates/store/src/state/state_db.rs
index 9644c98a4..0269616b7 100644
--- a/crates/store/src/state/state_db.rs
+++ b/crates/store/src/state/state_db.rs
@@ -458,7 +458,7 @@ impl<S: CodeStore> CodeStore for StateDB<S> {
     fn insert_script(&mut self, script_hash: H256, script: packed::Script) {
         self.journal.push(JournalEntry::InsertScript {
             script_hash,
-            prev_exist: self.get_script(&script_hash).is_some(),
+            prev_exist: self.dirty_scripts.contains_key(&script_hash),
         });
         self.dirty_scripts.insert(script_hash, script);
     }
@@ -480,7 +480,7 @@ impl<S: CodeStore> CodeStore for StateDB<S> {
         }
         self.journal.push(JournalEntry::InsertData {
             data_hash,
-            prev_exist: self.get_data(&data_hash).is_some(),
+            prev_exist: self.dirty_data.contains_key(&data_hash),
         });
         self.dirty_data.insert(data_hash, code);
     }

From 637105bf5f5ce68b109f24ff741e033af46c91da Mon Sep 17 00:00:00 2001
From: jjy <jjyruby@gmail.com>
Date: Wed, 2 Nov 2022 18:44:04 +0800
Subject: [PATCH 08/10] refactor: stop copying dirty StateDB state, so we can
 remove immutable structures

---
 crates/generator/src/generator.rs             |  2 +-
 crates/store/src/state/state_db.rs            | 50 +++++++++++--------
 crates/store/src/state/traits.rs              |  2 +-
 crates/tests/src/tests/meta_contract_args.rs  |  2 +
 .../src/tests/polyjuice_sender_recover.rs     |  2 +
 .../tests/rpc_server/execute_l2transaction.rs |  9 ++++
 .../block_max_cycles_limit.rs                 |  3 ++
 .../rpc_server/execute_raw_l2transaction.rs   |  7 ++-
 .../block_max_cycles_limit.rs                 |  3 ++
 .../tests/rpc_server/submit_l2transaction.rs  | 12 +++++
 10 files changed, 69 insertions(+), 23 deletions(-)

diff --git a/crates/generator/src/generator.rs b/crates/generator/src/generator.rs
index c3a7d1232..38669934d 100644
--- a/crates/generator/src/generator.rs
+++ b/crates/generator/src/generator.rs
@@ -802,7 +802,7 @@ impl Generator {
         }
         let r = RunResult {
             return_data: run_context.return_data,
-            logs: state.appended_logs().into_iter().cloned().collect(),
+            logs: state.appended_logs().to_vec(),
             exit_code: run_context.exit_code,
             cycles: run_context.cycle_meter,
             read_data_hashes: state_tracker
diff --git a/crates/store/src/state/state_db.rs b/crates/store/src/state/state_db.rs
index 0269616b7..dc9a5d991 100644
--- a/crates/store/src/state/state_db.rs
+++ b/crates/store/src/state/state_db.rs
@@ -75,7 +75,7 @@ impl JournalEntry {
             }
             AppendLog { index } => {
                 assert_eq!(state_db.dirty_logs.len(), index + 1);
-                state_db.dirty_logs.pop_back();
+                state_db.dirty_logs.pop();
             }
         }
     }
@@ -83,7 +83,7 @@ impl JournalEntry {
 
 #[derive(Debug, Default, Clone)]
 pub struct Journal {
-    entries: im::Vector<JournalEntry>,
+    entries: Vec<JournalEntry>,
 }
 
 impl Journal {
@@ -97,12 +97,12 @@ impl Journal {
 
     /// Revert journal to len
     /// Return reverted entries sorted in journal emit order
-    pub fn revert_entries(&mut self, len: usize) -> im::Vector<JournalEntry> {
-        self.entries.slice(len..)
+    pub fn revert_entries(&mut self, len: usize) -> Vec<JournalEntry> {
+        self.entries.split_off(len)
     }
 
     pub fn push(&mut self, entry: JournalEntry) {
-        self.entries.push_back(entry);
+        self.entries.push(entry);
     }
 
     pub fn clear(&mut self) {
@@ -151,25 +151,34 @@ pub struct StateDB<S> {
     /// next_revision_id
     next_revision_id: usize,
     /// revisions
-    revisions: im::Vector<Revision>,
+    revisions: Vec<Revision>,
     /// dirty state in memory
-    dirty_state: im::HashMap<H256, H256>,
+    dirty_state: HashMap<H256, H256>,
     /// dirty account count
     dirty_account_count: Option<u32>,
     /// dirty scripts
-    dirty_scripts: im::HashMap<H256, packed::Script>,
+    dirty_scripts: HashMap<H256, packed::Script>,
     /// dirty data
-    dirty_data: im::HashMap<H256, Bytes>,
+    dirty_data: HashMap<H256, Bytes>,
     /// dirty logs
-    dirty_logs: im::Vector<LogItem>,
+    dirty_logs: Vec<LogItem>,
     /// state tracker
     state_tracker: Option<StateTracker>,
     /// last state root
     last_state_root: H256,
 }
 
-impl<S: Clone> Clone for StateDB<S> {
+impl<S: Clone + State + CodeStore> Clone for StateDB<S> {
+    /// clone StateDB without dirty state
     fn clone(&self) -> Self {
+        Self::new(self.state.clone())
+    }
+}
+
+#[cfg(test)]
+impl<S: State + CodeStore + Clone> StateDB<S> {
+    /// clone StateDB with dirty state
+    pub(crate) fn clone_dirty(&self) -> Self {
         Self {
             state: self.state.clone(),
             journal: self.journal.clone(),
@@ -225,6 +234,7 @@ impl<Store: ChainStore + HistoryStateStore + CodeStore + KVStore> BlockStateDB<S
 
 impl<S: State + CodeStore> StateDB<S> {
     pub fn new(state: S) -> Self {
+        let last_state_root = state.calculate_root().expect("last state root");
         Self {
             state,
             journal: Journal::default(),
@@ -236,7 +246,7 @@ impl<S: State + CodeStore> StateDB<S> {
             dirty_scripts: Default::default(),
             dirty_logs: Default::default(),
             state_tracker: None,
-            last_state_root: H256::default(),
+            last_state_root,
         }
     }
 
@@ -325,7 +335,7 @@ impl<S: State + CodeStore> JournalDB for StateDB<S> {
     fn snapshot(&mut self) -> usize {
         let id = self.next_revision_id;
         self.next_revision_id += 1;
-        self.revisions.push_back(Revision {
+        self.revisions.push(Revision {
             id,
             journal_len: self.journal.len(),
         });
@@ -386,10 +396,10 @@ impl<S: State + CodeStore> JournalDB for StateDB<S> {
         self.journal.push(JournalEntry::AppendLog {
             index: self.dirty_logs.len(),
         });
-        self.dirty_logs.push_back(log);
+        self.dirty_logs.push(log);
     }
 
-    fn appended_logs(&self) -> &im::Vector<packed::LogItem> {
+    fn appended_logs(&self) -> &[packed::LogItem] {
         &self.dirty_logs
     }
 
@@ -561,7 +571,7 @@ mod tests {
     fn test_revert_to_histories_revision() {
         let store = Store::open_tmp().unwrap();
         let mut state = new_state(store.get_snapshot());
-        let mem_0 = state.clone();
+        let mem_0 = state.clone_dirty();
         let snap_0 = state.snapshot();
         state
             .update_raw(H256::from_u32(1), H256::from_u32(1))
@@ -569,14 +579,14 @@ mod tests {
         state
             .update_raw(H256::from_u32(2), H256::from_u32(2))
             .unwrap();
-        let mem_1 = state.clone();
+        let mem_1 = state.clone_dirty();
         let snap_1 = state.snapshot();
 
         // should update the mem DB
         state
             .update_raw(H256::from_u32(3), H256::from_u32(3))
             .unwrap();
-        let mem_2 = state.clone();
+        let mem_2 = state.clone_dirty();
         assert!(!cmp_dirty_state(&mem_1, &mem_2));
 
         // revert to snap_1
@@ -592,7 +602,7 @@ mod tests {
     fn test_clear_dirty_state() {
         let store = Store::open_tmp().unwrap();
         let mut state = new_state(store.get_snapshot());
-        let mem_0 = state.clone();
+        let mem_0 = state.clone_dirty();
         assert!(!state.is_dirty());
         state
             .update_raw(H256::from_u32(1), H256::from_u32(1))
@@ -620,7 +630,7 @@ mod tests {
         state
             .update_raw(H256::from_u32(2), H256::from_u32(2))
             .unwrap();
-        let mem_1 = state.clone();
+        let mem_1 = state.clone_dirty();
         assert!(state.is_dirty());
 
         // finalise
diff --git a/crates/store/src/state/traits.rs b/crates/store/src/state/traits.rs
index bc2eb7c84..98aab561a 100644
--- a/crates/store/src/state/traits.rs
+++ b/crates/store/src/state/traits.rs
@@ -10,7 +10,7 @@ pub trait SMTTree<S> {
 pub trait JournalDB {
     fn snapshot(&mut self) -> usize;
     fn revert(&mut self, id: usize) -> Result<(), gw_common::error::Error>;
-    fn appended_logs(&self) -> &im::Vector<LogItem>;
+    fn appended_logs(&self) -> &[LogItem];
     fn append_log(&mut self, log: LogItem);
     fn finalise(&mut self) -> Result<(), gw_common::error::Error>;
     fn set_state_tracker(&mut self, tracker: StateTracker);
diff --git a/crates/tests/src/tests/meta_contract_args.rs b/crates/tests/src/tests/meta_contract_args.rs
index 8a7722b7e..90f89be33 100644
--- a/crates/tests/src/tests/meta_contract_args.rs
+++ b/crates/tests/src/tests/meta_contract_args.rs
@@ -4,6 +4,7 @@ use gw_common::{
     state::State,
 };
 use gw_generator::account_lock_manage::secp256k1::Secp256k1Eth;
+use gw_store::state::traits::JournalDB;
 use gw_types::{
     packed::{
         CreateAccount, DeprecatedMetaContractArgs, Fee, L2Transaction, RawL2Transaction, Script,
@@ -73,6 +74,7 @@ async fn test_backward_compatibility() {
         .signature(sign.pack())
         .build();
 
+    state.finalise().unwrap();
     mem_pool_state.store_state_db(state);
     {
         let mut mem_pool = chain.mem_pool().await;
diff --git a/crates/tests/src/tests/polyjuice_sender_recover.rs b/crates/tests/src/tests/polyjuice_sender_recover.rs
index 44b71c48b..dc273b934 100644
--- a/crates/tests/src/tests/polyjuice_sender_recover.rs
+++ b/crates/tests/src/tests/polyjuice_sender_recover.rs
@@ -7,6 +7,7 @@ use gw_polyjuice_sender_recover::recover::{
     eth_account_creator::EthAccountCreator, eth_recover::EthAccountContext,
     eth_sender::PolyjuiceTxEthSender,
 };
+use gw_store::state::traits::JournalDB;
 use gw_types::{
     packed::{RawL2Transaction, Script},
     prelude::Pack,
@@ -87,6 +88,7 @@ async fn test_eth_account_creator() {
         .build_batch_create_tx(&state, recovered_account_scripts)
         .unwrap();
 
+    state.finalise().unwrap();
     mem_pool_state.store_state_db(state);
     {
         let mut mem_pool = chain.mem_pool().await;
diff --git a/crates/tests/src/tests/rpc_server/execute_l2transaction.rs b/crates/tests/src/tests/rpc_server/execute_l2transaction.rs
index 799219884..5254e2ce3 100644
--- a/crates/tests/src/tests/rpc_server/execute_l2transaction.rs
+++ b/crates/tests/src/tests/rpc_server/execute_l2transaction.rs
@@ -5,6 +5,7 @@ use gw_common::{
     state::State, H256,
 };
 use gw_polyjuice_sender_recover::recover::error::PolyjuiceTxSenderRecoverError;
+use gw_store::state::traits::JournalDB;
 use gw_types::{
     bytes::Bytes,
     packed::{RawL2Transaction, Script},
@@ -58,6 +59,7 @@ async fn test_polyjuice_erc20_tx() {
         .build();
     let deploy_tx = test_wallet.sign_polyjuice_tx(&state, raw_tx).unwrap();
 
+    state.finalise().unwrap();
     mem_pool_state.store_state_db(state);
     let run_result = rpc_server.execute_l2transaction(&deploy_tx).await.unwrap();
 
@@ -111,6 +113,7 @@ async fn test_polyjuice_tx_from_id_zero() {
     let deploy_tx = deployer_wallet.sign_polyjuice_tx(&state, raw_tx).unwrap();
     let deploy_tx_hash: H256 = deploy_tx.hash().into();
 
+    state.finalise().unwrap();
     mem_pool_state.store_state_db(state);
     {
         let mut mem_pool = chain.mem_pool().await;
@@ -159,6 +162,7 @@ async fn test_polyjuice_tx_from_id_zero() {
         .build();
     let balance_tx = test_wallet.sign_polyjuice_tx(&state, raw_tx).unwrap();
 
+    state.finalise().unwrap();
     mem_pool_state.store_state_db(state);
     let run_result = rpc_server.execute_l2transaction(&balance_tx).await.unwrap();
 
@@ -209,6 +213,7 @@ async fn test_invalid_polyjuice_tx_from_id_zero() {
         .unwrap();
     let deploy_tx_hash: H256 = deploy_tx.hash().into();
 
+    state.finalise().unwrap();
     mem_pool_state.store_state_db(state);
     {
         let mut mem_pool = chain.mem_pool().await;
@@ -300,6 +305,8 @@ async fn test_invalid_polyjuice_tx_from_id_zero() {
 
     let balance = 100u32.into();
     test_wallet.mint_ckb_sudt(&mut state, balance).unwrap();
+
+    state.finalise().unwrap();
     mem_pool_state.store_state_db(state);
 
     let err = rpc_server
@@ -316,6 +323,8 @@ async fn test_invalid_polyjuice_tx_from_id_zero() {
     state
         .mapping_registry_address_to_script_hash(test_wallet.reg_address().to_owned(), H256::one())
         .unwrap();
+
+    state.finalise().unwrap();
     mem_pool_state.store_state_db(state);
 
     let err = rpc_server
diff --git a/crates/tests/src/tests/rpc_server/execute_l2transaction/block_max_cycles_limit.rs b/crates/tests/src/tests/rpc_server/execute_l2transaction/block_max_cycles_limit.rs
index 6055a23a1..fcba8e448 100644
--- a/crates/tests/src/tests/rpc_server/execute_l2transaction/block_max_cycles_limit.rs
+++ b/crates/tests/src/tests/rpc_server/execute_l2transaction/block_max_cycles_limit.rs
@@ -1,6 +1,7 @@
 use ckb_types::prelude::{Builder, Entity};
 use gw_common::{builtins::CKB_SUDT_ACCOUNT_ID, registry_address::RegistryAddress};
 use gw_config::{MemBlockConfig, MemPoolConfig};
+use gw_store::state::traits::JournalDB;
 use gw_types::{
     bytes::Bytes,
     packed::{RawL2Transaction, Script},
@@ -70,6 +71,7 @@ async fn test_block_max_cycles_limit() {
         .build();
     let deploy_tx = test_wallet.sign_polyjuice_tx(&state, raw_tx).unwrap();
 
+    state.finalise().unwrap();
     mem_pool_state.store_state_db(state);
     let run_result = rpc_server.execute_l2transaction(&deploy_tx).await.unwrap();
 
@@ -120,6 +122,7 @@ async fn test_block_max_cycles_limit() {
         .build();
     let deploy_tx = test_wallet.sign_polyjuice_tx(&state, raw_tx).unwrap();
 
+    state.finalise().unwrap();
     mem_pool_state.store_state_db(state);
     let err = rpc_server
         .execute_l2transaction(&deploy_tx)
diff --git a/crates/tests/src/tests/rpc_server/execute_raw_l2transaction.rs b/crates/tests/src/tests/rpc_server/execute_raw_l2transaction.rs
index a399e24dd..4531c5cdd 100644
--- a/crates/tests/src/tests/rpc_server/execute_raw_l2transaction.rs
+++ b/crates/tests/src/tests/rpc_server/execute_raw_l2transaction.rs
@@ -6,7 +6,7 @@ use gw_common::{
     H256,
 };
 use gw_generator::account_lock_manage::secp256k1::Secp256k1Eth;
-use gw_store::state::{history::history_state::RWConfig, BlockStateDB};
+use gw_store::state::{history::history_state::RWConfig, traits::JournalDB, BlockStateDB};
 use gw_types::{
     bytes::Bytes,
     packed::{
@@ -65,6 +65,8 @@ async fn test_polyjuice_erc20_tx() {
         .build();
 
     let reg_addr_bytes = test_wallet.reg_address().to_bytes().into();
+
+    state.finalise().unwrap();
     mem_pool_state.store_state_db(state);
 
     let run_result = rpc_server
@@ -122,6 +124,7 @@ async fn test_polyjuice_tx_from_id_zero() {
     let deploy_tx = deployer_wallet.sign_polyjuice_tx(&state, raw_tx).unwrap();
     let deploy_tx_hash: H256 = deploy_tx.hash().into();
 
+    state.finalise().unwrap();
     mem_pool_state.store_state_db(state);
     {
         let mut mem_pool = chain.mem_pool().await;
@@ -162,6 +165,7 @@ async fn test_polyjuice_tx_from_id_zero() {
         .mint_sudt(&mut state, CKB_SUDT_ACCOUNT_ID, test_balance)
         .unwrap();
 
+    state.finalise().unwrap();
     mem_pool_state.store_state_db(state);
     let state = mem_pool_state.load_state_db();
 
@@ -486,6 +490,7 @@ async fn test_invalid_registry_address() {
     let deploy_tx = deployer_wallet.sign_polyjuice_tx(&state, raw_tx).unwrap();
     let deploy_tx_hash: H256 = deploy_tx.hash().into();
 
+    state.finalise().unwrap();
     mem_pool_state.store_state_db(state);
     {
         let mut mem_pool = chain.mem_pool().await;
diff --git a/crates/tests/src/tests/rpc_server/execute_raw_l2transaction/block_max_cycles_limit.rs b/crates/tests/src/tests/rpc_server/execute_raw_l2transaction/block_max_cycles_limit.rs
index 8208f592d..0b14789c4 100644
--- a/crates/tests/src/tests/rpc_server/execute_raw_l2transaction/block_max_cycles_limit.rs
+++ b/crates/tests/src/tests/rpc_server/execute_raw_l2transaction/block_max_cycles_limit.rs
@@ -1,6 +1,7 @@
 use ckb_types::prelude::{Builder, Entity};
 use gw_common::{builtins::CKB_SUDT_ACCOUNT_ID, registry_address::RegistryAddress};
 use gw_config::{MemBlockConfig, MemPoolConfig};
+use gw_store::state::traits::JournalDB;
 use gw_types::{
     bytes::Bytes,
     packed::{RawL2Transaction, Script},
@@ -70,6 +71,7 @@ async fn test_block_max_cycles_limit() {
         .build();
     let reg_addr_bytes = test_wallet.reg_address().to_bytes().into();
 
+    state.finalise().unwrap();
     mem_pool_state.store_state_db(state);
     let run_result = rpc_server
         .execute_raw_l2transaction(&raw_tx, None, Some(reg_addr_bytes))
@@ -123,6 +125,7 @@ async fn test_block_max_cycles_limit() {
         .build();
     let reg_addr_bytes = test_wallet.reg_address().to_bytes().into();
 
+    state.finalise().unwrap();
     mem_pool_state.store_state_db(state);
     let err = rpc_server
         .execute_raw_l2transaction(&raw_tx, None, Some(reg_addr_bytes))
diff --git a/crates/tests/src/tests/rpc_server/submit_l2transaction.rs b/crates/tests/src/tests/rpc_server/submit_l2transaction.rs
index a5ec9081a..280c347ae 100644
--- a/crates/tests/src/tests/rpc_server/submit_l2transaction.rs
+++ b/crates/tests/src/tests/rpc_server/submit_l2transaction.rs
@@ -8,6 +8,7 @@ use gw_common::{
     state::State,
     H256,
 };
+use gw_store::state::traits::JournalDB;
 use gw_types::{
     bytes::Bytes,
     packed::{Fee, RawL2Transaction, SUDTArgs, SUDTTransfer, Script},
@@ -52,6 +53,7 @@ async fn test_polyjuice_erc20_tx() {
         .build();
     let deploy_tx = creator_wallet.sign_polyjuice_tx(&state, raw_tx).unwrap();
 
+    state.finalise().unwrap();
     mem_pool_state.store_state_db(state);
     let deploy_tx_hash = rpc_server
         .submit_l2transaction(&deploy_tx)
@@ -141,6 +143,7 @@ async fn test_in_queue_query_with_signature_hash() {
     };
     let deploy_tx = test_wallet.sign_polyjuice_tx(&state, raw_tx).unwrap();
 
+    state.finalise().unwrap();
     mem_pool_state.store_state_db(state);
     let signature_hash = {
         let mut hasher = new_blake2b();
@@ -209,6 +212,7 @@ async fn test_polyjuice_tx_from_id_zero() {
     };
     let deploy_tx = test_wallet.sign_polyjuice_tx(&state, raw_tx).unwrap();
 
+    state.finalise().unwrap();
     mem_pool_state.store_state_db(state);
     rpc_server.submit_l2transaction(&deploy_tx).await.unwrap();
     wait_tx_committed(&chain, &deploy_tx_hash, Duration::from_secs(30))
@@ -271,6 +275,8 @@ async fn test_polyjuice_tx_from_id_zero() {
         raw.hash().into()
     };
     let deploy_tx = test_wallet.sign_polyjuice_tx(&state, raw_tx).unwrap();
+
+    state.finalise().unwrap();
     mem_pool_state.store_state_db(state);
 
     rpc_server.submit_l2transaction(&deploy_tx).await.unwrap();
@@ -341,6 +347,7 @@ async fn test_invalid_polyjuice_tx_from_id_zero() {
         .sign_polyjuice_tx(&state, raw_tx.clone())
         .unwrap();
 
+    state.finalise().unwrap();
     mem_pool_state.store_state_db(state);
     let err = rpc_server_no_creator
         .submit_l2transaction(&deploy_tx)
@@ -427,6 +434,8 @@ async fn test_invalid_polyjuice_tx_from_id_zero() {
     let insufficient_balance_deploy_tx = test_wallet
         .sign_polyjuice_tx(&state, raw_tx.clone())
         .unwrap();
+
+    state.finalise().unwrap();
     mem_pool_state.store_state_db(state);
 
     rpc_server
@@ -445,6 +454,8 @@ async fn test_invalid_polyjuice_tx_from_id_zero() {
         .unwrap();
 
     let different_script_deploy_tx = test_wallet.sign_polyjuice_tx(&state, raw_tx).unwrap();
+
+    state.finalise().unwrap();
     mem_pool_state.store_state_db(state);
 
     rpc_server
@@ -471,6 +482,7 @@ async fn test_invalid_polyjuice_tx_from_id_zero() {
         .build();
     let bad_deploy_tx = test_wallet.sign_polyjuice_tx(&state, raw_tx).unwrap();
 
+    state.finalise().unwrap();
     mem_pool_state.store_state_db(state);
     let err = rpc_server
         .submit_l2transaction(&bad_deploy_tx)

From 98c70fe0873f1e565adecf2298710ac6d8a0408f Mon Sep 17 00:00:00 2001
From: jjy <jjyruby@gmail.com>
Date: Thu, 3 Nov 2022 14:45:40 +0800
Subject: [PATCH 09/10] test: test reverted value

---
 crates/store/src/state/state_db.rs | 38 ++++++++++++++++++++++++++++++
 1 file changed, 38 insertions(+)

diff --git a/crates/store/src/state/state_db.rs b/crates/store/src/state/state_db.rs
index dc9a5d991..41322e65a 100644
--- a/crates/store/src/state/state_db.rs
+++ b/crates/store/src/state/state_db.rs
@@ -171,6 +171,7 @@ pub struct StateDB<S> {
 impl<S: Clone + State + CodeStore> Clone for StateDB<S> {
     /// clone StateDB without dirty state
     fn clone(&self) -> Self {
+        debug_assert!(!self.is_dirty(), "can't clone dirty state");
         Self::new(self.state.clone())
     }
 }
@@ -598,6 +599,43 @@ mod tests {
         assert!(cmp_dirty_state(&mem_0, &state));
     }
 
+    #[test]
+    fn test_revert_to_histories_value() {
+        let store = Store::open_tmp().unwrap();
+        let mut state = new_state(store.get_snapshot());
+        let snap_0 = state.snapshot();
+        state
+            .update_raw(H256::from_u32(1), H256::from_u32(1))
+            .unwrap();
+        let mem_1 = state.clone_dirty();
+        let snap_1 = state.snapshot();
+
+        // should update the mem DB
+        state
+            .update_raw(H256::from_u32(1), H256::from_u32(2))
+            .unwrap();
+        state
+            .update_raw(H256::from_u32(1), H256::from_u32(3))
+            .unwrap();
+        let mem_2 = state.clone_dirty();
+        assert!(!cmp_dirty_state(&mem_1, &mem_2));
+        assert_eq!(
+            state.get_raw(&H256::from_u32(1)).unwrap(),
+            H256::from_u32(3)
+        );
+
+        // revert to snap_1
+        state.revert(snap_1).unwrap();
+        assert_eq!(
+            state.get_raw(&H256::from_u32(1)).unwrap(),
+            H256::from_u32(1)
+        );
+
+        // revert to snap_0
+        state.revert(snap_0).unwrap();
+        assert_eq!(state.get_raw(&H256::from_u32(1)).unwrap(), H256::zero());
+    }
+
     #[test]
     fn test_clear_dirty_state() {
         let store = Store::open_tmp().unwrap();

From 968b5b33b7d6437ab74b4fc58427a88dad0d1b49 Mon Sep 17 00:00:00 2001
From: Yin Guanhao <sopium@mysterious.site>
Date: Thu, 3 Nov 2022 15:00:38 +0800
Subject: [PATCH 10/10] perf: use drain in revert

---
 crates/store/src/state/state_db.rs | 85 ++++++++++++++----------------
 1 file changed, 39 insertions(+), 46 deletions(-)

diff --git a/crates/store/src/state/state_db.rs b/crates/store/src/state/state_db.rs
index 41322e65a..c8ca1164f 100644
--- a/crates/store/src/state/state_db.rs
+++ b/crates/store/src/state/state_db.rs
@@ -10,6 +10,7 @@
 use std::{
     collections::{HashMap, HashSet},
     sync::Mutex,
+    vec::Drain,
 };
 
 use anyhow::Result;
@@ -37,7 +38,7 @@ use super::{
 };
 
 #[derive(Debug, Clone)]
-pub enum JournalEntry {
+enum JournalEntry {
     UpdateRaw { key: H256, prev_value: H256 },
     SetAccountCount { prev_count: u32 },
     InsertScript { script_hash: H256, prev_exist: bool },
@@ -45,67 +46,31 @@ pub enum JournalEntry {
     AppendLog { index: usize },
 }
 
-impl JournalEntry {
-    /// revert journal
-    pub fn revert<S>(self, state_db: &mut StateDB<S>) {
-        use JournalEntry::*;
-
-        match self {
-            UpdateRaw { key, prev_value } => {
-                state_db.dirty_state.insert(key, prev_value);
-            }
-            SetAccountCount { prev_count } => {
-                state_db.dirty_account_count = Some(prev_count);
-            }
-            InsertScript {
-                script_hash,
-                prev_exist,
-            } => {
-                if !prev_exist {
-                    state_db.dirty_scripts.remove(&script_hash);
-                }
-            }
-            InsertData {
-                data_hash,
-                prev_exist,
-            } => {
-                if !prev_exist {
-                    state_db.dirty_data.remove(&data_hash);
-                }
-            }
-            AppendLog { index } => {
-                assert_eq!(state_db.dirty_logs.len(), index + 1);
-                state_db.dirty_logs.pop();
-            }
-        }
-    }
-}
-
 #[derive(Debug, Default, Clone)]
-pub struct Journal {
+struct Journal {
     entries: Vec<JournalEntry>,
 }
 
 impl Journal {
-    pub fn len(&self) -> usize {
+    fn len(&self) -> usize {
         self.entries.len()
     }
 
-    pub fn is_empty(&self) -> bool {
+    fn is_empty(&self) -> bool {
         self.entries.is_empty()
     }
 
     /// Revert journal to len
     /// Return reverted entries sorted in journal emit order
-    pub fn revert_entries(&mut self, len: usize) -> Vec<JournalEntry> {
-        self.entries.split_off(len)
+    fn revert_entries(&mut self, len: usize) -> Drain<'_, JournalEntry> {
+        self.entries.drain(len..)
     }
 
-    pub fn push(&mut self, entry: JournalEntry) {
+    fn push(&mut self, entry: JournalEntry) {
         self.entries.push(entry);
     }
 
-    pub fn clear(&mut self) {
+    fn clear(&mut self) {
         self.entries.clear();
     }
 }
@@ -357,8 +322,36 @@ impl<S: State + CodeStore> JournalDB for StateDB<S> {
 
         // replay to revert journal
         let revert_entries = self.journal.revert_entries(rev.journal_len);
-        for entry in revert_entries.into_iter().rev() {
-            entry.revert(self);
+        for entry in revert_entries.rev() {
+            use JournalEntry::*;
+            match entry {
+                UpdateRaw { key, prev_value } => {
+                    self.dirty_state.insert(key, prev_value);
+                }
+                SetAccountCount { prev_count } => {
+                    self.dirty_account_count = Some(prev_count);
+                }
+                InsertScript {
+                    script_hash,
+                    prev_exist,
+                } => {
+                    if !prev_exist {
+                        self.dirty_scripts.remove(&script_hash);
+                    }
+                }
+                InsertData {
+                    data_hash,
+                    prev_exist,
+                } => {
+                    if !prev_exist {
+                        self.dirty_data.remove(&data_hash);
+                    }
+                }
+                AppendLog { index } => {
+                    assert_eq!(self.dirty_logs.len(), index + 1);
+                    self.dirty_logs.pop();
+                }
+            }
         }
 
         // remove expired revisions