From 70fcc69eeb3262dfee19623cbe1d71b6fbe9803e Mon Sep 17 00:00:00 2001
From: Stan Bondi <sdbondi@users.noreply.github.com>
Date: Wed, 18 Sep 2024 17:13:09 +0400
Subject: [PATCH] fix(engine): simplify and improve state store performance
 (#1143)

Description
---
Removes unnecessary locks in MemoryStateStore
Remove de/encoding from MemoryStateStore
Removed unused lmdb implementation and lmdb_zero dep

Motivation and Context
---
MemoryStateStore now uses a hashmap internally without locks. The engine
only requires read access to the provided inputs. Key and value types
are always SubstateId and Substate respectively, the generic en/decoding
to/from CBOR no longer necessary.

How Has This Been Tested?
---
Existing tests and manually

What process can a PR reviewer use to test or verify this change?
---
Execution time should be slightly reduced, exact gain is not
deteremined.

Breaking Changes
---

- [x] None
- [ ] Requires data directory to be deleted
- [ ] Other - Please specify
---
 Cargo.lock                                    |  14 --
 Cargo.toml                                    |   2 -
 .../src/transaction_executor.rs               |   8 +-
 .../tari_indexer/src/dry_run/processor.rs     |   7 +-
 .../consensus/block_transaction_executor.rs   |  22 +-
 .../src/dry_run_transaction_processor.rs      |   8 +-
 .../src/support/transaction_executor.rs       |  18 +-
 dan_layer/engine/src/runtime/error.rs         |   4 +-
 dan_layer/engine/src/runtime/state_store.rs   |  61 +++--
 dan_layer/engine/src/runtime/tracker.rs       |   4 +-
 dan_layer/engine/src/runtime/working_state.rs |   4 +-
 dan_layer/engine/src/state_store/bootstrap.rs |  21 +-
 dan_layer/engine/src/state_store/memory.rs    | 210 ++++--------------
 dan_layer/engine/src/state_store/mod.rs       |  66 +-----
 dan_layer/engine/src/transaction/processor.rs |   6 +-
 dan_layer/engine/tests/test.rs                |   9 +-
 dan_layer/storage_lmdb/Cargo.toml             |  21 --
 .../storage_lmdb/src/engine_state_store.rs    | 171 --------------
 dan_layer/storage_lmdb/src/lib.rs             |  23 --
 .../src/read_only_state_store.rs              |  25 +--
 .../src/template_test.rs                      |  84 +++----
 21 files changed, 168 insertions(+), 620 deletions(-)
 delete mode 100644 dan_layer/storage_lmdb/Cargo.toml
 delete mode 100644 dan_layer/storage_lmdb/src/engine_state_store.rs
 delete mode 100644 dan_layer/storage_lmdb/src/lib.rs

diff --git a/Cargo.lock b/Cargo.lock
index 3bf791ae9..c2ffdee88 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -9191,20 +9191,6 @@ dependencies = [
  "ts-rs",
 ]
 
-[[package]]
-name = "tari_dan_storage_lmdb"
-version = "0.7.0"
-dependencies = [
- "hex",
- "lmdb-zero",
- "serde",
- "tari_bor",
- "tari_dan_common_types",
- "tari_dan_engine",
- "tari_storage",
- "tempfile",
-]
-
 [[package]]
 name = "tari_dan_storage_sqlite"
 version = "0.7.0"
diff --git a/Cargo.toml b/Cargo.toml
index cc5262886..0ed956e22 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -30,7 +30,6 @@ members = [
     "dan_layer/rpc_state_sync",
     "dan_layer/state_store_sqlite",
     "dan_layer/state_tree",
-    "dan_layer/storage_lmdb",
     "dan_layer/storage_sqlite",
     "dan_layer/storage",
     "dan_layer/tari_bor",
@@ -193,7 +192,6 @@ libp2p = { git = "https://github.com/tari-project/rust-libp2p.git", rev = "0dccc
 libsqlite3-sys = "0.25"
 liquid = "0.26.4"
 liquid-core = "0.26.4"
-lmdb-zero = "0.4.4"
 log = "0.4.20"
 log4rs = "1.3"
 mime_guess = "2.0.4"
diff --git a/applications/tari_dan_app_utilities/src/transaction_executor.rs b/applications/tari_dan_app_utilities/src/transaction_executor.rs
index 034320a08..f634ea63d 100644
--- a/applications/tari_dan_app_utilities/src/transaction_executor.rs
+++ b/applications/tari_dan_app_utilities/src/transaction_executor.rs
@@ -16,7 +16,7 @@ use tari_dan_common_types::{
 use tari_dan_engine::{
     fees::{FeeModule, FeeTable},
     runtime::{AuthParams, RuntimeModule},
-    state_store::{memory::MemoryStateStore, StateStoreError},
+    state_store::{memory::ReadOnlyMemoryStateStore, StateStoreError},
     template::LoadedTemplate,
     transaction::{TransactionError, TransactionProcessor},
 };
@@ -33,7 +33,7 @@ pub trait TransactionExecutor {
     fn execute(
         &self,
         transaction: Transaction,
-        state_store: MemoryStateStore,
+        state_store: ReadOnlyMemoryStateStore,
         virtual_substates: VirtualSubstates,
     ) -> Result<ExecutionOutput, Self::Error>;
 }
@@ -110,7 +110,7 @@ where TTemplateProvider: TemplateProvider<Template = LoadedTemplate>
     fn execute(
         &self,
         transaction: Transaction,
-        state_store: MemoryStateStore,
+        state_store: ReadOnlyMemoryStateStore,
         virtual_substates: VirtualSubstates,
     ) -> Result<ExecutionOutput, Self::Error> {
         // Include signature public key badges for all transaction signers in the initial auth scope
@@ -129,7 +129,7 @@ where TTemplateProvider: TemplateProvider<Template = LoadedTemplate>
 
         let processor = TransactionProcessor::new(
             self.template_provider.clone(),
-            state_store.clone(),
+            state_store,
             auth_params,
             virtual_substates,
             modules,
diff --git a/applications/tari_indexer/src/dry_run/processor.rs b/applications/tari_indexer/src/dry_run/processor.rs
index 744ca1a79..52f1423c5 100644
--- a/applications/tari_indexer/src/dry_run/processor.rs
+++ b/applications/tari_indexer/src/dry_run/processor.rs
@@ -111,12 +111,13 @@ where TSubstateCache: SubstateCache + 'static
 
         let virtual_substates = self.get_virtual_substates(&transaction, epoch).await?;
 
-        let state_store = new_memory_store();
+        let mut state_store = new_memory_store();
         state_store.set_many(found_substates)?;
 
         // execute the payload in the WASM engine and return the result
-        let exec_output =
-            task::block_in_place(|| payload_processor.execute(transaction, state_store, virtual_substates))?;
+        let exec_output = task::block_in_place(|| {
+            payload_processor.execute(transaction, state_store.into_read_only(), virtual_substates)
+        })?;
 
         Ok(exec_output.result)
     }
diff --git a/applications/tari_validator_node/src/consensus/block_transaction_executor.rs b/applications/tari_validator_node/src/consensus/block_transaction_executor.rs
index e5608ace5..4b134cd0b 100644
--- a/applications/tari_validator_node/src/consensus/block_transaction_executor.rs
+++ b/applications/tari_validator_node/src/consensus/block_transaction_executor.rs
@@ -7,7 +7,7 @@ use log::info;
 use tari_consensus::traits::{BlockTransactionExecutor, BlockTransactionExecutorError};
 use tari_dan_app_utilities::transaction_executor::TransactionExecutor;
 use tari_dan_common_types::{Epoch, SubstateRequirement};
-use tari_dan_engine::state_store::{memory::MemoryStateStore, new_memory_store, AtomicDb, StateWriter};
+use tari_dan_engine::state_store::{memory::MemoryStateStore, new_memory_store, StateWriter};
 use tari_dan_storage::{consensus_models::ExecutedTransaction, StateStore};
 use tari_engine_types::{
     substate::Substate,
@@ -36,22 +36,14 @@ where TExecutor: TransactionExecutor
     }
 
     fn add_substates_to_memory_db<'a, I: IntoIterator<Item = (&'a SubstateRequirement, &'a Substate)>>(
-        &self,
         inputs: I,
-        out: &MemoryStateStore,
+        out: &mut MemoryStateStore,
     ) -> Result<(), BlockTransactionExecutorError> {
-        // TODO: pass the impl SubstateStore directly into the engine
-        let mut access = out
-            .write_access()
-            .map_err(|e| BlockTransactionExecutorError::StateStoreError(e.to_string()))?;
+        // TODO: pass the SubstateStore directly into the engine
         for (id, substate) in inputs {
-            access
-                .set_state(id.substate_id(), substate)
+            out.set_state(id.substate_id().clone(), substate.clone())
                 .map_err(|e| BlockTransactionExecutorError::StateStoreError(e.to_string()))?;
         }
-        access
-            .commit()
-            .map_err(|e| BlockTransactionExecutorError::StateStoreError(e.to_string()))?;
 
         Ok(())
     }
@@ -87,8 +79,8 @@ where
         info!(target: LOG_TARGET, "Transaction {} executing. {} input(s)", id, resolved_inputs.len());
 
         // Create a memory db with all the input substates, needed for the transaction execution
-        let state_db = new_memory_store();
-        self.add_substates_to_memory_db(resolved_inputs, &state_db)?;
+        let mut state_db = new_memory_store();
+        Self::add_substates_to_memory_db(resolved_inputs, &mut state_db)?;
 
         let mut virtual_substates = VirtualSubstates::new();
         virtual_substates.insert(
@@ -99,7 +91,7 @@ where
         // Execute the transaction and get the result
         let exec_output = self
             .executor
-            .execute(transaction, state_db, virtual_substates)
+            .execute(transaction, state_db.into_read_only(), virtual_substates)
             .map_err(|e| BlockTransactionExecutorError::ExecutionThreadFailure(e.to_string()))?;
 
         // Generate the resolved inputs to set the specific version and required lock flag, as we know it after
diff --git a/applications/tari_validator_node/src/dry_run_transaction_processor.rs b/applications/tari_validator_node/src/dry_run_transaction_processor.rs
index 589ed7089..5d62eb8a4 100644
--- a/applications/tari_validator_node/src/dry_run_transaction_processor.rs
+++ b/applications/tari_validator_node/src/dry_run_transaction_processor.rs
@@ -104,7 +104,7 @@ impl DryRunTransactionProcessor {
         transaction: Transaction,
     ) -> Result<ExecuteResult, DryRunTransactionProcessorError> {
         // Resolve all local and foreign substates
-        let temp_state_store = new_memory_store();
+        let mut temp_state_store = new_memory_store();
 
         let current_epoch = self.epoch_manager.current_epoch().await?;
         let virtual_substates = self
@@ -124,8 +124,10 @@ impl DryRunTransactionProcessor {
 
         // execute the payload in the WASM engine and return the result
         let processor = self.payload_processor.clone();
-        let exec_output =
-            task::spawn_blocking(move || processor.execute(transaction, temp_state_store, virtual_substates)).await??;
+        let exec_output = task::spawn_blocking(move || {
+            processor.execute(transaction, temp_state_store.into_read_only(), virtual_substates)
+        })
+        .await??;
         let result = exec_output.result;
 
         let fees = &result.finalize.fee_receipt;
diff --git a/dan_layer/consensus_tests/src/support/transaction_executor.rs b/dan_layer/consensus_tests/src/support/transaction_executor.rs
index 72c432908..e81ca68c9 100644
--- a/dan_layer/consensus_tests/src/support/transaction_executor.rs
+++ b/dan_layer/consensus_tests/src/support/transaction_executor.rs
@@ -5,7 +5,7 @@ use std::{collections::HashMap, iter};
 
 use tari_consensus::traits::{BlockTransactionExecutor, BlockTransactionExecutorError};
 use tari_dan_common_types::{Epoch, LockIntent, SubstateRequirement, VersionedSubstateId};
-use tari_dan_engine::state_store::{memory::MemoryStateStore, new_memory_store, AtomicDb, StateWriter};
+use tari_dan_engine::state_store::{memory::MemoryStateStore, new_memory_store, StateWriter};
 use tari_dan_storage::{
     consensus_models::{ExecutedTransaction, VersionedSubstateIdLockIntent},
     StateStore,
@@ -30,22 +30,14 @@ impl TestBlockTransactionProcessor {
     }
 
     fn add_substates_to_memory_db<'a, I: IntoIterator<Item = (&'a SubstateRequirement, &'a Substate)>>(
-        &self,
         inputs: I,
-        out: &MemoryStateStore,
+        out: &mut MemoryStateStore,
     ) -> Result<(), BlockTransactionExecutorError> {
         // TODO: pass the impl SubstateStore directly into the engine
-        let mut access = out
-            .write_access()
-            .map_err(|e| BlockTransactionExecutorError::StateStoreError(e.to_string()))?;
         for (id, substate) in inputs {
-            access
-                .set_state(id.substate_id(), substate)
+            out.set_state(id.substate_id().clone(), substate.clone())
                 .map_err(|e| BlockTransactionExecutorError::StateStoreError(e.to_string()))?;
         }
-        access
-            .commit()
-            .map_err(|e| BlockTransactionExecutorError::StateStoreError(e.to_string()))?;
 
         Ok(())
     }
@@ -72,8 +64,8 @@ impl<TStateStore: StateStore> BlockTransactionExecutor<TStateStore> for TestBloc
         log::info!("Transaction {} executing. {} input(s)", id, resolved_inputs.len());
 
         // Create a memory db with all the input substates, needed for the transaction execution
-        let state_db = new_memory_store();
-        self.add_substates_to_memory_db(resolved_inputs, &state_db)?;
+        let mut state_db = new_memory_store();
+        Self::add_substates_to_memory_db(resolved_inputs, &mut state_db)?;
 
         let mut virtual_substates = VirtualSubstates::new();
         virtual_substates.insert(
diff --git a/dan_layer/engine/src/runtime/error.rs b/dan_layer/engine/src/runtime/error.rs
index b07bdf289..2d302241a 100644
--- a/dan_layer/engine/src/runtime/error.rs
+++ b/dan_layer/engine/src/runtime/error.rs
@@ -67,8 +67,8 @@ pub enum RuntimeError {
     StateStoreError(#[from] StateStoreError),
     #[error("Workspace error: {0}")]
     WorkspaceError(#[from] WorkspaceError),
-    #[error("Substate not found with address '{address}'")]
-    SubstateNotFound { address: SubstateId },
+    #[error("Substate '{id}' not found")]
+    SubstateNotFound { id: SubstateId },
     #[error("Root substate not found with address '{address}'")]
     RootSubstateNotFound { address: SubstateId },
     #[error("Referenced substate not found with address '{address}'")]
diff --git a/dan_layer/engine/src/runtime/state_store.rs b/dan_layer/engine/src/runtime/state_store.rs
index 6b5503ab2..c53a51625 100644
--- a/dan_layer/engine/src/runtime/state_store.rs
+++ b/dan_layer/engine/src/runtime/state_store.rs
@@ -18,7 +18,7 @@ use crate::{
         locking::{LockError, LockedSubstates},
         RuntimeError,
     },
-    state_store::{memory::MemoryStateStore, AtomicDb, StateReader},
+    state_store::{memory::ReadOnlyMemoryStateStore, StateReader},
 };
 
 #[derive(Debug, Clone)]
@@ -29,11 +29,11 @@ pub struct WorkingStateStore {
     loaded_substates: HashMap<SubstateId, SubstateValue>,
     locked_substates: LockedSubstates,
 
-    state_store: MemoryStateStore,
+    state_store: ReadOnlyMemoryStateStore,
 }
 
 impl WorkingStateStore {
-    pub fn new(state_store: MemoryStateStore) -> Self {
+    pub fn new(state_store: ReadOnlyMemoryStateStore) -> Self {
         Self {
             new_substates: IndexMap::new(),
             loaded_substates: HashMap::new(),
@@ -44,9 +44,7 @@ impl WorkingStateStore {
 
     pub fn try_lock(&mut self, address: &SubstateId, lock_flag: LockFlag) -> Result<LockId, RuntimeError> {
         if !self.exists(address)? {
-            return Err(RuntimeError::SubstateNotFound {
-                address: address.clone(),
-            });
+            return Err(RuntimeError::SubstateNotFound { id: address.clone() });
         }
         let lock_id = self.locked_substates.try_lock(address, lock_flag)?;
         self.load(address)?;
@@ -131,38 +129,35 @@ impl WorkingStateStore {
         })
     }
 
-    pub fn exists(&self, address: &SubstateId) -> Result<bool, RuntimeError> {
-        let exists = self.new_substates.contains_key(address) || self.loaded_substates.contains_key(address) || {
-            let tx = self.state_store.read_access()?;
-            tx.exists(address)?
-        };
+    pub fn exists(&self, id: &SubstateId) -> Result<bool, RuntimeError> {
+        let exists = self.new_substates.contains_key(id) ||
+            self.loaded_substates.contains_key(id) ||
+            self.state_store.exists(id)?;
         Ok(exists)
     }
 
-    pub fn insert(&mut self, address: SubstateId, value: SubstateValue) -> Result<(), RuntimeError> {
-        if self.exists(&address)? {
-            return Err(RuntimeError::DuplicateSubstate { address });
+    pub fn insert(&mut self, id: SubstateId, value: SubstateValue) -> Result<(), RuntimeError> {
+        if self.exists(&id)? {
+            return Err(RuntimeError::DuplicateSubstate { address: id });
         }
-        self.new_substates.insert(address, value);
+        self.new_substates.insert(id, value);
         Ok(())
     }
 
-    fn load(&mut self, address: &SubstateId) -> Result<(), RuntimeError> {
-        if self.new_substates.contains_key(address) {
+    fn load(&mut self, id: &SubstateId) -> Result<(), RuntimeError> {
+        if self.new_substates.contains_key(id) {
             return Ok(());
         }
-        if self.loaded_substates.contains_key(address) {
+        if self.loaded_substates.contains_key(id) {
             return Ok(());
         }
-        let tx = self.state_store.read_access()?;
-        let substate =
-            tx.get_state::<_, Substate>(address)
-                .optional()?
-                .ok_or_else(|| RuntimeError::SubstateNotFound {
-                    address: address.clone(),
-                })?;
-        let substate = substate.into_substate_value();
-        self.loaded_substates.insert(address.clone(), substate);
+        let substate = self
+            .state_store
+            .get_state(id)
+            .optional()?
+            .ok_or_else(|| RuntimeError::SubstateNotFound { id: id.clone() })?;
+        let substate = substate.substate_value().clone();
+        self.loaded_substates.insert(id.clone(), substate);
         Ok(())
     }
 
@@ -181,7 +176,7 @@ impl WorkingStateStore {
             .map(|(addr, vault)| (addr.as_vault_id().unwrap(), vault.as_vault().unwrap()))
     }
 
-    pub(super) fn state_store(&self) -> &MemoryStateStore {
+    pub(super) fn state_store(&self) -> &ReadOnlyMemoryStateStore {
         &self.state_store
     }
 
@@ -196,12 +191,10 @@ impl WorkingStateStore {
         })
     }
 
-    pub(super) fn get_unmodified_substate(&self, address: &SubstateId) -> Result<Substate, RuntimeError> {
-        let tx = self.state_store.read_access()?;
-        tx.get_state(address)
+    pub(super) fn get_unmodified_substate(&self, address: &SubstateId) -> Result<&Substate, RuntimeError> {
+        self.state_store
+            .get_state(address)
             .optional()?
-            .ok_or_else(|| RuntimeError::SubstateNotFound {
-                address: address.clone(),
-            })
+            .ok_or_else(|| RuntimeError::SubstateNotFound { id: address.clone() })
     }
 }
diff --git a/dan_layer/engine/src/runtime/tracker.rs b/dan_layer/engine/src/runtime/tracker.rs
index 05b411310..11676d60e 100644
--- a/dan_layer/engine/src/runtime/tracker.rs
+++ b/dan_layer/engine/src/runtime/tracker.rs
@@ -56,7 +56,7 @@ use crate::{
         workspace::Workspace,
         RuntimeError,
     },
-    state_store::memory::MemoryStateStore,
+    state_store::memory::ReadOnlyMemoryStateStore,
 };
 
 const LOG_TARGET: &str = "tari::dan::engine::runtime::state_tracker";
@@ -69,7 +69,7 @@ pub struct StateTracker {
 
 impl StateTracker {
     pub fn new(
-        state_store: MemoryStateStore,
+        state_store: ReadOnlyMemoryStateStore,
         virtual_substates: VirtualSubstates,
         initial_call_scope: CallScope,
         transaction_hash: Hash,
diff --git a/dan_layer/engine/src/runtime/working_state.rs b/dan_layer/engine/src/runtime/working_state.rs
index 90d1e9fb4..1814b5bb8 100644
--- a/dan_layer/engine/src/runtime/working_state.rs
+++ b/dan_layer/engine/src/runtime/working_state.rs
@@ -62,7 +62,7 @@ use crate::{
         RuntimeError,
         TransactionCommitError,
     },
-    state_store::memory::MemoryStateStore,
+    state_store::memory::ReadOnlyMemoryStateStore,
 };
 
 const LOG_TARGET: &str = "dan::engine::runtime::working_state";
@@ -93,7 +93,7 @@ pub(super) struct WorkingState {
 
 impl WorkingState {
     pub fn new(
-        state_store: MemoryStateStore,
+        state_store: ReadOnlyMemoryStateStore,
         virtual_substates: VirtualSubstates,
         initial_call_scope: CallScope,
         transaction_hash: Hash,
diff --git a/dan_layer/engine/src/state_store/bootstrap.rs b/dan_layer/engine/src/state_store/bootstrap.rs
index 44808c3b0..5bd1025e5 100644
--- a/dan_layer/engine/src/state_store/bootstrap.rs
+++ b/dan_layer/engine/src/state_store/bootstrap.rs
@@ -13,27 +13,24 @@ use tari_template_lib::{
     resource::TOKEN_SYMBOL,
 };
 
-use crate::state_store::{memory::MemoryStateStore, AtomicDb, StateStoreError, StateWriter};
+use crate::state_store::{memory::MemoryStateStore, StateStoreError, StateWriter};
 
 pub fn new_memory_store() -> MemoryStateStore {
-    let state_db = MemoryStateStore::new();
-    // unwrap: Memory state store is infallible
-    let mut tx = state_db.write_access().unwrap();
+    let mut state_db = MemoryStateStore::new();
     // Add shared global resources
-    add_global_resources(&mut tx).unwrap();
-    tx.commit().unwrap();
+    add_global_resources(&mut state_db).unwrap();
     state_db
 }
 
 /// These are implicitly included in every transaction. These are immutable and pledging them is not required.
 fn add_global_resources<T: StateWriter>(state_db: &mut T) -> Result<(), StateStoreError> {
-    let address = SubstateId::Resource(PUBLIC_IDENTITY_RESOURCE_ADDRESS);
+    let id = SubstateId::Resource(PUBLIC_IDENTITY_RESOURCE_ADDRESS);
     let mut metadata = Metadata::new();
     metadata.insert(TOKEN_SYMBOL, "ID".to_string());
     // Create the resource for badges
     state_db.set_state(
-        &address,
-        &Substate::new(
+        id,
+        Substate::new(
             0,
             Resource::new(
                 ResourceType::NonFungible,
@@ -48,12 +45,12 @@ fn add_global_resources<T: StateWriter>(state_db: &mut T) -> Result<(), StateSto
     )?;
 
     // Create the second layer tari resource
-    let address = SubstateId::Resource(CONFIDENTIAL_TARI_RESOURCE_ADDRESS);
+    let id = SubstateId::Resource(CONFIDENTIAL_TARI_RESOURCE_ADDRESS);
     let mut metadata = Metadata::new();
     metadata.insert(TOKEN_SYMBOL, "XTR".to_string());
     state_db.set_state(
-        &address,
-        &Substate::new(
+        id,
+        Substate::new(
             0,
             Resource::new(
                 ResourceType::Confidential,
diff --git a/dan_layer/engine/src/state_store/memory.rs b/dan_layer/engine/src/state_store/memory.rs
index 45264f799..1c15f9c7f 100644
--- a/dan_layer/engine/src/state_store/memory.rs
+++ b/dan_layer/engine/src/state_store/memory.rs
@@ -19,22 +19,15 @@
 //  SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 //  WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
 //  USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-use std::{
-    collections::HashMap,
-    sync::{Arc, RwLock, RwLockReadGuard, RwLockWriteGuard},
-};
+use std::{collections::HashMap, sync::Arc};
 
-use anyhow::anyhow;
-use serde::Serialize;
-use tari_utilities::hex::to_hex;
+use tari_engine_types::substate::{Substate, SubstateId};
 
-use crate::state_store::{AtomicDb, StateReader, StateStoreError, StateWriter};
+use crate::state_store::{StateReader, StateStoreError, StateWriter};
 
-type InnerKvMap = HashMap<Vec<u8>, Vec<u8>>;
-
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Default)]
 pub struct MemoryStateStore {
-    state: Arc<RwLock<InnerKvMap>>,
+    state: HashMap<SubstateId, Substate>,
 }
 
 impl MemoryStateStore {
@@ -42,183 +35,74 @@ impl MemoryStateStore {
         Self::default()
     }
 
-    pub fn set_many<T: IntoIterator<Item = (K, V)>, K: Serialize, V: Serialize>(
-        &self,
-        iter: T,
-    ) -> Result<(), StateStoreError> {
-        let mut state = self.write_access()?;
-        for (k, v) in iter {
-            state.set_state(&k, &v)?;
-        }
-        state.commit()
+    pub fn set_many<T: IntoIterator<Item = (SubstateId, Substate)>>(&mut self, iter: T) -> Result<(), StateStoreError> {
+        self.state.extend(iter);
+        Ok(())
     }
-}
 
-impl Default for MemoryStateStore {
-    fn default() -> Self {
-        Self {
-            state: Arc::new(RwLock::new(HashMap::new())),
-        }
+    pub fn count(&self) -> usize {
+        self.state.len()
     }
-}
-
-pub type MemoryReadTransaction<'a> = MemoryTransaction<RwLockReadGuard<'a, InnerKvMap>>;
-pub type MemoryWriteTransaction<'a> = MemoryTransaction<RwLockWriteGuard<'a, InnerKvMap>>;
-
-pub struct MemoryTransaction<T> {
-    pending: InnerKvMap,
-    guard: T,
-}
 
-impl MemoryTransaction<RwLockReadGuard<'_, InnerKvMap>> {
-    pub fn iter_raw(&self) -> impl Iterator<Item = (&[u8], &[u8])> {
-        self.pending.iter().map(|(k, v)| (k.as_slice(), v.as_slice())).chain(
-            self.guard
-                .iter()
-                .filter(|(k, _)| !self.pending.contains_key(*k))
-                .map(|(k, v)| (k.as_slice(), v.as_slice())),
-        )
+    pub fn iter(&self) -> impl Iterator<Item = (&SubstateId, &Substate)> {
+        self.state.iter()
     }
-}
-
-impl<'a> AtomicDb<'a> for MemoryStateStore {
-    type Error = anyhow::Error;
-    type ReadAccess = MemoryReadTransaction<'a>;
-    type WriteAccess = MemoryWriteTransaction<'a>;
-
-    fn read_access(&'a self) -> Result<Self::ReadAccess, Self::Error> {
-        let guard = self.state.read().map_err(|_| anyhow!("Failed to read state"))?;
 
-        Ok(MemoryTransaction {
-            pending: HashMap::default(),
-            guard,
-        })
+    pub fn delete_state(&mut self, key: &SubstateId) {
+        self.state.remove(key);
     }
 
-    fn write_access(&'a self) -> Result<Self::WriteAccess, Self::Error> {
-        let guard = self.state.write().map_err(|_| anyhow!("Failed to write state"))?;
-
-        Ok(MemoryTransaction {
-            pending: HashMap::default(),
-            guard,
-        })
+    pub fn into_read_only(self) -> ReadOnlyMemoryStateStore {
+        ReadOnlyMemoryStateStore {
+            state: Arc::new(self.state),
+        }
     }
 }
 
-impl<'a> StateReader for MemoryTransaction<RwLockReadGuard<'a, InnerKvMap>> {
-    fn get_state_raw(&self, key: &[u8]) -> Result<Vec<u8>, StateStoreError> {
-        self.pending
-            .get(key)
-            .cloned()
-            .or_else(|| self.guard.get(key).cloned())
-            .ok_or_else(|| StateStoreError::NotFound {
-                kind: "state",
-                key: to_hex(key),
-            })
+impl StateReader for MemoryStateStore {
+    fn get_state(&self, key: &SubstateId) -> Result<&Substate, StateStoreError> {
+        self.state.get(key).ok_or_else(|| StateStoreError::NotFound {
+            kind: "state",
+            key: key.to_string(),
+        })
     }
 
-    fn exists_raw(&self, key: &[u8]) -> Result<bool, StateStoreError> {
-        Ok(self.pending.contains_key(key) || self.guard.contains_key(key))
+    fn exists(&self, key: &SubstateId) -> Result<bool, StateStoreError> {
+        Ok(self.state.contains_key(key))
     }
 }
 
-impl<'a> StateReader for MemoryTransaction<RwLockWriteGuard<'a, InnerKvMap>> {
-    fn get_state_raw(&self, key: &[u8]) -> Result<Vec<u8>, StateStoreError> {
-        self.pending
-            .get(key)
-            .cloned()
-            .or_else(|| self.guard.get(key).cloned())
-            .ok_or_else(|| StateStoreError::NotFound {
-                kind: "state",
-                key: to_hex(key),
-            })
-    }
-
-    fn exists_raw(&self, key: &[u8]) -> Result<bool, StateStoreError> {
-        Ok(self.pending.contains_key(key) || self.guard.contains_key(key))
+impl StateWriter for MemoryStateStore {
+    fn set_state(&mut self, key: SubstateId, value: Substate) -> Result<(), StateStoreError> {
+        self.state.insert(key, value);
+        Ok(())
     }
 }
 
-impl<'a> StateWriter for MemoryTransaction<RwLockWriteGuard<'a, InnerKvMap>> {
-    fn set_state_raw(&mut self, key: &[u8], value: Vec<u8>) -> Result<(), StateStoreError> {
-        self.pending.insert(key.to_vec(), value);
-        Ok(())
-    }
+#[derive(Debug, Clone, Default)]
+pub struct ReadOnlyMemoryStateStore {
+    state: Arc<HashMap<SubstateId, Substate>>,
+}
 
-    fn delete_state_raw(&mut self, key: &[u8]) -> Result<(), StateStoreError> {
-        let pending_exist = self.pending.remove(key);
-        let lock_exist = self.guard.remove(key);
-        if pending_exist.is_none() && lock_exist.is_none() {
-            return Err(StateStoreError::NotFound {
-                kind: "state",
-                key: to_hex(key),
-            });
-        }
-        Ok(())
+impl ReadOnlyMemoryStateStore {
+    pub fn count(&self) -> usize {
+        self.state.len()
     }
 
-    fn commit(mut self) -> Result<(), StateStoreError> {
-        self.guard.extend(self.pending);
-        Ok(())
+    pub fn iter(&self) -> impl Iterator<Item = (&SubstateId, &Substate)> {
+        self.state.iter()
     }
 }
 
-#[cfg(test)]
-mod tests {
-    use serde::{Deserialize, Serialize};
-    use tari_dan_common_types::optional::Optional;
-
-    use super::*;
-
-    #[test]
-    fn read_write() {
-        let store = MemoryStateStore::default();
-        let mut access = store.write_access().unwrap();
-        access.set_state_raw(b"abc", vec![1, 2, 3]).unwrap();
-        let res = access.get_state_raw(b"abc").unwrap();
-        assert_eq!(res, vec![1, 2, 3]);
-        let res = access.get_state_raw(b"def").optional().unwrap();
-        assert_eq!(res, None);
+impl StateReader for ReadOnlyMemoryStateStore {
+    fn get_state(&self, key: &SubstateId) -> Result<&Substate, StateStoreError> {
+        self.state.get(key).ok_or_else(|| StateStoreError::NotFound {
+            kind: "state",
+            key: key.to_string(),
+        })
     }
 
-    #[test]
-    fn read_write_rollback_commit() {
-        #[derive(Debug, Serialize, Deserialize, PartialEq, Eq, Clone)]
-        struct UserData {
-            name: String,
-            age: u8,
-        }
-
-        let user_data = UserData {
-            name: "Foo".to_string(),
-            age: 99,
-        };
-
-        let store = MemoryStateStore::default();
-        {
-            let mut access = store.write_access().unwrap();
-            access.set_state(b"abc", &user_data).unwrap();
-            let res: UserData = access.get_state(b"abc").unwrap();
-            assert_eq!(res, user_data);
-            let res = access.get_state::<_, UserData>(b"def").optional().unwrap();
-            assert_eq!(res, None);
-            // Drop without commit rolls back
-        }
-
-        {
-            let access = store.read_access().unwrap();
-            let res = access.get_state::<_, UserData>(b"abc").optional().unwrap();
-            assert_eq!(res, None);
-        }
-
-        {
-            let mut access = store.write_access().unwrap();
-            access.set_state(b"abc", &user_data).unwrap();
-            access.commit().unwrap();
-        }
-
-        let access = store.read_access().unwrap();
-        let res: UserData = access.get_state(b"abc").unwrap();
-        assert_eq!(res, user_data);
+    fn exists(&self, key: &SubstateId) -> Result<bool, StateStoreError> {
+        Ok(self.state.contains_key(key))
     }
 }
diff --git a/dan_layer/engine/src/state_store/mod.rs b/dan_layer/engine/src/state_store/mod.rs
index b3cbfe876..253734889 100644
--- a/dan_layer/engine/src/state_store/mod.rs
+++ b/dan_layer/engine/src/state_store/mod.rs
@@ -26,80 +26,22 @@ pub mod memory;
 
 use std::{error::Error, fmt::Debug};
 
-use serde::{de::DeserializeOwned, Serialize};
-use tari_bor::{decode_exact, encode, BorError};
 use tari_dan_common_types::optional::IsNotFoundError;
-
-// pub trait StateStorage<'a>: AtomicDb<'a, Error = StateStoreError> + Send + Sync {}
-//
-// impl<'a, T> StateStorage<'a> for T
-// where
-//     T: AtomicDb<'a, Error = StateStoreError> + Send + Sync,
-//     T::ReadAccess: StateReader,
-//     T::WriteAccess: StateWriter,
-// {
-// }
-
-/// Abstraction for any database that has atomic read/write semantics.
-pub trait AtomicDb<'a> {
-    type Error;
-    type ReadAccess: 'a;
-    type WriteAccess: 'a;
-
-    /// Obtain read access to the underlying database
-    fn read_access(&'a self) -> Result<Self::ReadAccess, Self::Error>;
-
-    /// Obtain write access to the underlying database
-    fn write_access(&'a self) -> Result<Self::WriteAccess, Self::Error>;
-}
+use tari_engine_types::substate::{Substate, SubstateId};
 
 pub trait StateReader {
-    fn get_state_raw(&self, key: &[u8]) -> Result<Vec<u8>, StateStoreError>;
-
-    fn get_state<K: Serialize + Debug, V: DeserializeOwned>(&self, key: &K) -> Result<V, StateStoreError> {
-        let value = self.get_state_raw(&encode(key)?)?;
-        let value = decode_exact(&value).map_err(|err| StateStoreError::ValueDecodeError {
-            key: format!("{:?}", key),
-            value_type: std::any::type_name::<V>(),
-            err,
-        })?;
-        Ok(value)
-    }
-
-    fn exists_raw(&self, key: &[u8]) -> Result<bool, StateStoreError>;
-    fn exists<K: Serialize + Debug>(&self, key: &K) -> Result<bool, StateStoreError> {
-        self.exists_raw(&encode(key)?)
-    }
+    fn get_state(&self, key: &SubstateId) -> Result<&Substate, StateStoreError>;
+    fn exists(&self, key: &SubstateId) -> Result<bool, StateStoreError>;
 }
 
 pub trait StateWriter: StateReader {
-    fn set_state_raw(&mut self, key: &[u8], value: Vec<u8>) -> Result<(), StateStoreError>;
-
-    fn set_state<K: Serialize, V: Serialize>(&mut self, key: &K, value: &V) -> Result<(), StateStoreError> {
-        self.set_state_raw(&encode(key)?, encode(value)?)
-    }
-
-    fn delete_state_raw(&mut self, key: &[u8]) -> Result<(), StateStoreError>;
-
-    fn delete_state<K: Serialize>(&mut self, key: &K) -> Result<(), StateStoreError> {
-        self.delete_state_raw(&encode(key)?)
-    }
-
-    fn commit(self) -> Result<(), StateStoreError>;
+    fn set_state(&mut self, key: SubstateId, value: Substate) -> Result<(), StateStoreError>;
 }
 
 #[derive(Debug, thiserror::Error)]
 pub enum StateStoreError {
     #[error("Non existent shard: {shard:?}")]
     NonExistentShard { shard: Vec<u8> },
-    #[error("State store decode error for {value_type} at key '{key}': {err:?}")]
-    ValueDecodeError {
-        key: String,
-        value_type: &'static str,
-        err: BorError,
-    },
-    #[error("State store encoding error: {0}")]
-    EncodingError(#[from] BorError),
     #[error(transparent)]
     Custom(#[from] anyhow::Error),
     #[error("Error: {0}")]
diff --git a/dan_layer/engine/src/transaction/processor.rs b/dan_layer/engine/src/transaction/processor.rs
index b6bfaa81e..83284a7c2 100644
--- a/dan_layer/engine/src/transaction/processor.rs
+++ b/dan_layer/engine/src/transaction/processor.rs
@@ -62,7 +62,7 @@ use crate::{
         RuntimeModule,
         StateTracker,
     },
-    state_store::memory::MemoryStateStore,
+    state_store::memory::ReadOnlyMemoryStateStore,
     template::LoadedTemplate,
     traits::Invokable,
     transaction::TransactionError,
@@ -75,7 +75,7 @@ const ACCOUNT_CONSTRUCTOR_FUNCTION: &str = "create";
 
 pub struct TransactionProcessor<TTemplateProvider> {
     template_provider: Arc<TTemplateProvider>,
-    state_db: MemoryStateStore,
+    state_db: ReadOnlyMemoryStateStore,
     auth_params: AuthParams,
     virtual_substates: VirtualSubstates,
     modules: Vec<Arc<dyn RuntimeModule>>,
@@ -85,7 +85,7 @@ pub struct TransactionProcessor<TTemplateProvider> {
 impl<TTemplateProvider: TemplateProvider<Template = LoadedTemplate> + 'static> TransactionProcessor<TTemplateProvider> {
     pub fn new(
         template_provider: Arc<TTemplateProvider>,
-        state_db: MemoryStateStore,
+        state_db: ReadOnlyMemoryStateStore,
         auth_params: AuthParams,
         virtual_substates: VirtualSubstates,
         modules: Vec<Arc<dyn RuntimeModule>>,
diff --git a/dan_layer/engine/tests/test.rs b/dan_layer/engine/tests/test.rs
index b15923308..a581e8676 100644
--- a/dan_layer/engine/tests/test.rs
+++ b/dan_layer/engine/tests/test.rs
@@ -56,7 +56,6 @@ fn test_hello_world() {
 #[test]
 fn test_state() {
     let mut template_test = TemplateTest::new(vec!["tests/templates/state"]);
-    let store = template_test.read_only_state_store();
 
     // constructor
     let component_address1: ComponentAddress = template_test.call_function("State", "new", args![], vec![]);
@@ -70,6 +69,7 @@ fn test_state() {
     let component_address2: ComponentAddress = template_test.call_function("State", "new", args![], vec![]);
     assert_ne!(component_address1, component_address2);
 
+    let store = template_test.read_only_state_store();
     let component = store.get_component(component_address1).unwrap();
     assert_eq!(component.module_name, "State");
 
@@ -90,14 +90,14 @@ fn test_state() {
 #[test]
 fn state_create_multiple_in_one_call() {
     let mut template_test = TemplateTest::new(["tests/templates/state"]);
-    let store = template_test.read_only_state_store();
 
     // constructor
     template_test.call_function::<()>("State", "create_multiple", args![10u32], vec![]);
 
     let template_address = template_test.get_template_address("State");
     let mut count = 0usize;
-    store
+    template_test
+        .read_only_state_store()
         .with_substates(|s| {
             if s.substate_value()
                 .component()
@@ -240,8 +240,7 @@ fn test_engine_errors() {
     // call returned null for op VaultInvoke)
     assert_eq!(
         reason,
-        "Runtime error: Substate not found with address \
-         'resource_7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b'"
+        "Runtime error: Substate 'resource_7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b' not found"
     );
 }
 
diff --git a/dan_layer/storage_lmdb/Cargo.toml b/dan_layer/storage_lmdb/Cargo.toml
deleted file mode 100644
index 8793f0d86..000000000
--- a/dan_layer/storage_lmdb/Cargo.toml
+++ /dev/null
@@ -1,21 +0,0 @@
-[package]
-name = "tari_dan_storage_lmdb"
-description = "LMDB implementation of the Tari Storage API"
-version.workspace = true
-edition.workspace = true
-authors.workspace = true
-repository.workspace = true
-license.workspace = true
-
-[dependencies]
-tari_bor = { workspace = true, default-features = true }
-tari_dan_engine = { workspace = true }
-tari_dan_common_types = { workspace = true }
-tari_storage = { workspace = true }
-
-lmdb-zero = { workspace = true }
-hex = { workspace = true }
-serde = { workspace = true, default-features = false, features = ["derive", "alloc"] }
-
-[dev-dependencies]
-tempfile = { workspace = true }
diff --git a/dan_layer/storage_lmdb/src/engine_state_store.rs b/dan_layer/storage_lmdb/src/engine_state_store.rs
deleted file mode 100644
index 3f048dd6e..000000000
--- a/dan_layer/storage_lmdb/src/engine_state_store.rs
+++ /dev/null
@@ -1,171 +0,0 @@
-//  Copyright 2022. The Tari Project
-//
-//  Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
-//  following conditions are met:
-//
-//  1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following
-//  disclaimer.
-//
-//  2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the
-//  following disclaimer in the documentation and/or other materials provided with the distribution.
-//
-//  3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote
-//  products derived from this software without specific prior written permission.
-//
-//  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
-//  INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-//  DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-//  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-//  SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
-//  WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
-//  USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-use std::{ops::Deref, path::Path, sync::Arc};
-
-use lmdb_zero::{db, put, ConstTransaction, LmdbResultExt, ReadTransaction, WriteTransaction};
-use tari_bor::encode;
-use tari_dan_common_types::optional::Optional;
-use tari_dan_engine::state_store::{AtomicDb, StateReader, StateStoreError, StateWriter};
-use tari_storage::lmdb_store::{DatabaseRef, LMDBBuilder};
-
-pub struct LmdbTransaction<T> {
-    db: DatabaseRef,
-    tx: T,
-}
-
-pub struct LmdbStateStore {
-    pub env: Arc<lmdb_zero::Environment>,
-    pub db: DatabaseRef,
-}
-
-impl LmdbStateStore {
-    pub fn new<P: AsRef<Path>>(path: P) -> Self {
-        let flags = db::CREATE;
-        std::fs::create_dir_all(&path).unwrap();
-
-        let store = LMDBBuilder::new()
-            .set_path(path)
-            // .set_env_config(config)
-            .set_max_number_of_databases(1)
-            .add_database("test_db", flags )
-            .build().unwrap();
-
-        let handle = store.get_handle("test_db").unwrap();
-        let db = handle.db();
-        Self { env: store.env(), db }
-    }
-}
-
-impl<'a> AtomicDb<'a> for LmdbStateStore {
-    type Error = lmdb_zero::Error;
-    type ReadAccess = LmdbTransaction<ReadTransaction<'a>>;
-    type WriteAccess = LmdbTransaction<WriteTransaction<'a>>;
-
-    fn read_access(&'a self) -> Result<Self::ReadAccess, Self::Error> {
-        let tx = ReadTransaction::new(self.env.clone())?;
-
-        Ok(LmdbTransaction {
-            db: self.db.clone(),
-            tx,
-        })
-    }
-
-    fn write_access(&'a self) -> Result<Self::WriteAccess, Self::Error> {
-        let tx = WriteTransaction::new(self.env.clone())?;
-
-        Ok(LmdbTransaction {
-            db: self.db.clone(),
-            tx,
-        })
-    }
-}
-
-impl<'a, T: Deref<Target = ConstTransaction<'a>>> StateReader for LmdbTransaction<T> {
-    fn get_state_raw(&self, key: &[u8]) -> Result<Vec<u8>, StateStoreError> {
-        let access = self.tx.access();
-        access
-            .get::<_, [u8]>(&self.db, key)
-            .map(|data| data.to_vec())
-            .to_opt()
-            .map_err(StateStoreError::custom)?
-            .ok_or_else(|| StateStoreError::NotFound {
-                kind: "state",
-                key: hex::encode(key),
-            })
-    }
-
-    fn exists_raw(&self, key: &[u8]) -> Result<bool, StateStoreError> {
-        Ok(self.get_state_raw(&encode(key)?).optional()?.is_some())
-    }
-}
-
-impl<'a> StateWriter for LmdbTransaction<WriteTransaction<'a>> {
-    fn set_state_raw(&mut self, key: &[u8], value: Vec<u8>) -> Result<(), StateStoreError> {
-        let mut access = self.tx.access();
-        access
-            .put(&self.db, key, &value, put::Flags::empty())
-            .map_err(StateStoreError::custom)
-    }
-
-    fn delete_state_raw(&mut self, key: &[u8]) -> Result<(), StateStoreError> {
-        let mut access = self.tx.access();
-        access.del_key(&self.db, key).map_err(StateStoreError::custom)
-    }
-
-    fn commit(self) -> Result<(), StateStoreError> {
-        self.tx.commit().map_err(StateStoreError::custom)?;
-        Ok(())
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use serde::{Deserialize, Serialize};
-    use tempfile::tempdir;
-
-    use super::*;
-
-    #[derive(Debug, Serialize, Deserialize, PartialEq, Eq, Clone)]
-    struct UserData {
-        name: String,
-        age: u8,
-    }
-
-    #[test]
-    fn read_write_rollback_commit() {
-        let user_data = UserData {
-            name: "Foo".to_string(),
-            age: 99,
-        };
-
-        let path = tempdir().unwrap();
-        let store = LmdbStateStore::new(&path);
-        {
-            let mut access = store.write_access().unwrap();
-            access.set_state(b"abc", &user_data).unwrap();
-            assert!(access.exists_raw(b"abc").unwrap());
-            let res: UserData = access.get_state(b"abc").unwrap();
-            assert_eq!(res, user_data);
-            let res = access.get_state::<_, UserData>(b"def").optional().unwrap();
-            assert_eq!(res, None);
-            // Drop without commit rolls back
-        }
-
-        {
-            let access = store.read_access().unwrap();
-            let res = access.get_state::<_, UserData>(b"abc").optional().unwrap();
-            assert_eq!(res, None);
-            assert!(!access.exists_raw(b"abc").unwrap());
-        }
-
-        {
-            let mut access = store.write_access().unwrap();
-            access.set_state(b"abc", &user_data).unwrap();
-            access.commit().unwrap();
-        }
-
-        let access = store.read_access().unwrap();
-        let res: UserData = access.get_state(b"abc").unwrap();
-        assert_eq!(res, user_data);
-    }
-}
diff --git a/dan_layer/storage_lmdb/src/lib.rs b/dan_layer/storage_lmdb/src/lib.rs
deleted file mode 100644
index 25fc6bb78..000000000
--- a/dan_layer/storage_lmdb/src/lib.rs
+++ /dev/null
@@ -1,23 +0,0 @@
-//  Copyright 2022. The Tari Project
-//
-//  Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
-//  following conditions are met:
-//
-//  1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following
-//  disclaimer.
-//
-//  2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the
-//  following disclaimer in the documentation and/or other materials provided with the distribution.
-//
-//  3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote
-//  products derived from this software without specific prior written permission.
-//
-//  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
-//  INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-//  DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-//  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-//  SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
-//  WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
-//  USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-pub mod engine_state_store;
diff --git a/dan_layer/template_test_tooling/src/read_only_state_store.rs b/dan_layer/template_test_tooling/src/read_only_state_store.rs
index 667813d67..01a887108 100644
--- a/dan_layer/template_test_tooling/src/read_only_state_store.rs
+++ b/dan_layer/template_test_tooling/src/read_only_state_store.rs
@@ -1,8 +1,7 @@
 //   Copyright 2023 The Tari Project
 //   SPDX-License-Identifier: BSD-3-Clause
 
-use tari_bor::decode_exact;
-use tari_dan_engine::state_store::{memory::MemoryStateStore, AtomicDb, StateReader, StateStoreError};
+use tari_dan_engine::state_store::{memory::MemoryStateStore, StateReader, StateStoreError};
 use tari_engine_types::{
     component::ComponentHeader,
     indexed_value::IndexedValue,
@@ -12,11 +11,11 @@ use tari_engine_types::{
 };
 use tari_template_lib::models::{ComponentAddress, ResourceAddress, VaultId};
 
-pub struct ReadOnlyStateStore {
-    store: MemoryStateStore,
+pub struct ReadOnlyStateStore<'a> {
+    store: &'a MemoryStateStore,
 }
-impl ReadOnlyStateStore {
-    pub fn new(store: MemoryStateStore) -> Self {
+impl<'a> ReadOnlyStateStore<'a> {
+    pub fn new(store: &'a MemoryStateStore) -> Self {
         Self { store }
     }
 
@@ -41,22 +40,18 @@ impl ReadOnlyStateStore {
     }
 
     pub fn count(&self) -> Result<usize, StateStoreError> {
-        let tx = self.store.read_access()?;
-        let count = tx.iter_raw().count();
+        let count = self.store.count();
         Ok(count)
     }
 
-    pub fn get_substate(&self, address: &SubstateId) -> Result<Substate, StateStoreError> {
-        let tx = self.store.read_access()?;
-        let substate = tx.get_state::<_, Substate>(address)?;
-        Ok(substate)
+    pub fn get_substate(&self, id: &SubstateId) -> Result<Substate, StateStoreError> {
+        let substate = self.store.get_state(id)?;
+        Ok(substate.clone())
     }
 
     pub fn with_substates<F>(&self, mut f: F) -> Result<(), StateStoreError>
     where F: FnMut(Substate) {
-        let tx = self.store.read_access()?;
-        tx.iter_raw()
-            .for_each(|(_, substate)| f(decode_exact(substate).unwrap()));
+        self.store.iter().for_each(|(_, substate)| f(substate.clone()));
         Ok(())
     }
 }
diff --git a/dan_layer/template_test_tooling/src/template_test.rs b/dan_layer/template_test_tooling/src/template_test.rs
index c42a050b2..c2731be6f 100644
--- a/dan_layer/template_test_tooling/src/template_test.rs
+++ b/dan_layer/template_test_tooling/src/template_test.rs
@@ -10,7 +10,7 @@ use std::{
 
 use anyhow::anyhow;
 use serde::de::DeserializeOwned;
-use tari_bor::{decode_exact, to_value};
+use tari_bor::to_value;
 use tari_common::configuration::Network;
 use tari_common_types::types::PublicKey;
 use tari_crypto::{
@@ -22,12 +22,7 @@ use tari_dan_common_types::{crypto::create_key_pair_from_seed, VersionedSubstate
 use tari_dan_engine::{
     fees::{FeeModule, FeeTable},
     runtime::{AuthParams, RuntimeModule},
-    state_store::{
-        memory::{MemoryStateStore, MemoryWriteTransaction},
-        new_memory_store,
-        AtomicDb,
-        StateWriter,
-    },
+    state_store::{memory::MemoryStateStore, new_memory_store, StateWriter},
     template::LoadedTemplate,
     transaction::{TransactionError, TransactionProcessor},
     wasm::LoadedWasmTemplate,
@@ -93,7 +88,7 @@ impl TemplateTest {
 
         let package = builder.build();
 
-        let test = Self::from_package(package);
+        let mut test = Self::from_package(package);
         test.bootstrap_state(100_000.into());
         test
     }
@@ -138,19 +133,13 @@ impl TemplateTest {
         }
     }
 
-    pub fn bootstrap_state(&self, amount: Amount) {
-        let mut tx = self.state_store.write_access().unwrap();
-        Self::initial_tari_faucet_supply(
-            &mut tx,
-            &self.public_key,
-            amount,
-            self.get_template_address("TestFaucet"),
-        );
-        tx.commit().unwrap();
+    pub fn bootstrap_state(&mut self, amount: Amount) {
+        let template_addr = self.get_template_address("TestFaucet");
+        Self::initial_tari_faucet_supply(&mut self.state_store, &self.public_key, amount, template_addr);
     }
 
     fn initial_tari_faucet_supply(
-        tx: &mut MemoryWriteTransaction<'_>,
+        store: &mut MemoryStateStore,
         signer_public_key: &RistrettoPublicKey,
         initial_supply: Amount,
         test_faucet_template_address: TemplateAddress,
@@ -164,7 +153,8 @@ impl TemplateTest {
             vec![],
             initial_supply,
         ));
-        tx.set_state(&SubstateId::Vault(vault_id), &Substate::new(0, vault))
+        store
+            .set_state(SubstateId::Vault(vault_id), Substate::new(0, vault))
             .unwrap();
 
         // This must mirror the test faucet component
@@ -176,19 +166,20 @@ impl TemplateTest {
             vault: tari_template_lib::models::Vault::for_test(vault_id),
         })
         .unwrap();
-        tx.set_state(
-            &SubstateId::Component(test_faucet_component()),
-            &Substate::new(0, ComponentHeader {
-                template_address: test_faucet_template_address,
-                module_name: "TestFaucet".to_string(),
-                owner_key: Some(RistrettoPublicKeyBytes::from_bytes(signer_public_key.as_bytes()).unwrap()),
-                owner_rule: OwnerRule::None,
-                access_rules: ComponentAccessRules::allow_all(),
-                entity_id,
-                body: ComponentBody { state },
-            }),
-        )
-        .unwrap();
+        store
+            .set_state(
+                SubstateId::Component(test_faucet_component()),
+                Substate::new(0, ComponentHeader {
+                    template_address: test_faucet_template_address,
+                    module_name: "TestFaucet".to_string(),
+                    owner_key: Some(RistrettoPublicKeyBytes::from_bytes(signer_public_key.as_bytes()).unwrap()),
+                    owner_rule: OwnerRule::None,
+                    access_rules: ComponentAccessRules::allow_all(),
+                    entity_id,
+                    body: ComponentBody { state },
+                }),
+            )
+            .unwrap();
     }
 
     pub fn enable_fees(&mut self) -> &mut Self {
@@ -215,8 +206,8 @@ impl TemplateTest {
         self
     }
 
-    pub fn read_only_state_store(&self) -> ReadOnlyStateStore {
-        ReadOnlyStateStore::new(self.state_store.clone())
+    pub fn read_only_state_store(&self) -> ReadOnlyStateStore<'_> {
+        ReadOnlyStateStore::new(&self.state_store)
     }
 
     pub fn extract_component_value<T: DeserializeOwned>(&self, component_address: ComponentAddress, path: &str) -> T {
@@ -251,20 +242,17 @@ impl TemplateTest {
 
     fn commit_diff(&mut self, diff: &SubstateDiff) {
         self.last_outputs.clear();
-        let mut tx = self.state_store.write_access().unwrap();
 
         for (address, _) in diff.down_iter() {
             eprintln!("DOWN substate: {}", address);
-            tx.delete_state(address).unwrap();
+            self.state_store.delete_state(address);
         }
 
         for (address, substate) in diff.up_iter() {
             eprintln!("UP substate: {}", address);
             self.last_outputs.insert(address.clone());
-            tx.set_state(address, substate).unwrap();
+            self.state_store.set_state(address.clone(), substate.clone()).unwrap();
         }
-
-        tx.commit().unwrap();
     }
 
     pub fn get_module(&self, module_name: &str) -> &LoadedWasmTemplate {
@@ -487,7 +475,7 @@ impl TemplateTest {
         };
         let processor = TransactionProcessor::new(
             self.package.clone(),
-            self.state_store.clone(),
+            self.state_store.clone().into_read_only(),
             auth_params,
             self.virtual_substates.clone(),
             modules,
@@ -495,12 +483,10 @@ impl TemplateTest {
         );
 
         {
-            let access = self.state_store.read_access().unwrap();
             transaction.filled_inputs_mut().extend(
-                access
-                    .iter_raw()
-                    .map(|(k, s)| (SubstateId::from_bytes(k).unwrap(), Substate::from_bytes(s).unwrap()))
-                    .map(|(id, s)| VersionedSubstateId::new(id, s.version())),
+                self.state_store
+                    .iter()
+                    .map(|(id, s)| VersionedSubstateId::new(id.clone(), s.version())),
             );
         }
 
@@ -632,12 +618,8 @@ impl TemplateTest {
     }
 
     pub fn print_state(&self) {
-        let tx = self.state_store.read_access().unwrap();
-        for (k, v) in tx.iter_raw() {
-            let k: SubstateId = decode_exact(k).unwrap();
-            let v: Substate = decode_exact(v).unwrap();
-
-            eprintln!("[{}]: {}", k, v.into_substate_value());
+        for (k, v) in self.state_store.iter() {
+            eprintln!("[{}]: {}", k, v.substate_value());
         }
     }
 }