diff --git a/Cargo.lock b/Cargo.lock
index 287b161d6..c17707e6f 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -9395,7 +9395,6 @@ version = "0.5.1"
 dependencies = [
  "base64 0.21.7",
  "blake2",
- "borsh",
  "digest 0.10.7",
  "hex",
  "lazy_static",
@@ -9542,6 +9541,7 @@ name = "tari_indexer_lib"
 version = "0.5.1"
 dependencies = [
  "async-trait",
+ "futures 0.3.30",
  "log",
  "rand",
  "serde",
@@ -9995,6 +9995,7 @@ dependencies = [
 name = "tari_transaction"
 version = "0.5.1"
 dependencies = [
+ "indexmap 2.2.6",
  "rand",
  "serde",
  "tari_common_types",
diff --git a/Cargo.toml b/Cargo.toml
index aa927af14..b7f2b773a 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -179,7 +179,7 @@ httpmock = "0.6.8"
 humantime = "2.1.0"
 humantime-serde = "1.1.1"
 include_dir = "0.7.2"
-indexmap = "2.1.0"
+indexmap = "2.2.6"
 indoc = "1.0.6"
 itertools = "0.11.0"
 lazy_static = "1.4.0"
diff --git a/applications/tari_dan_app_utilities/Cargo.toml b/applications/tari_dan_app_utilities/Cargo.toml
index 46955e54f..ffbc8b267 100644
--- a/applications/tari_dan_app_utilities/Cargo.toml
+++ b/applications/tari_dan_app_utilities/Cargo.toml
@@ -26,7 +26,7 @@ tari_transaction = { workspace = true }
 tari_validator_node_client = { workspace = true }
 tari_bor = { workspace = true, default-features = true }
 tari_indexer_lib = { workspace = true }
-tari_networking = { workspace = true}
+tari_networking = { workspace = true }
 tari_validator_node_rpc = { workspace = true }
 
 anyhow = { workspace = true }
@@ -49,11 +49,11 @@ serde = { workspace = true, features = ["default", "derive"] }
 serde_json = { workspace = true }
 thiserror = { workspace = true }
 tokio = { workspace = true, features = [
-  "default",
-  "macros",
-  "time",
-  "sync",
-  "rt-multi-thread",
-]}
+    "default",
+    "macros",
+    "time",
+    "sync",
+    "rt-multi-thread",
+] }
 tokio-stream = { workspace = true, features = ["sync"] }
 config = { workspace = true }
diff --git a/applications/tari_dan_app_utilities/src/transaction_executor.rs b/applications/tari_dan_app_utilities/src/transaction_executor.rs
index 24d5f5d79..e1904011f 100644
--- a/applications/tari_dan_app_utilities/src/transaction_executor.rs
+++ b/applications/tari_dan_app_utilities/src/transaction_executor.rs
@@ -76,7 +76,7 @@ where TTemplateProvider: TemplateProvider<Template = LoadedTemplate>
 
         let processor = TransactionProcessor::new(
             self.template_provider.clone(),
-            state_store,
+            state_store.clone(),
             auth_params,
             virtual_substates,
             modules,
diff --git a/applications/tari_dan_wallet_daemon/src/handlers/accounts.rs b/applications/tari_dan_wallet_daemon/src/handlers/accounts.rs
index e7e9a75a5..f2a4c0948 100644
--- a/applications/tari_dan_wallet_daemon/src/handlers/accounts.rs
+++ b/applications/tari_dan_wallet_daemon/src/handlers/accounts.rs
@@ -106,11 +106,6 @@ pub async fn handle_create(
         .locate_dependent_substates(&[default_account.address.clone()])
         .await?;
 
-    // We aren't mutating the resources
-    let (input_refs, inputs) = inputs
-        .into_iter()
-        .partition::<Vec<_>, _>(|s| s.substate_id.is_resource());
-
     let signing_key_index = req.key_id.unwrap_or(default_account.key_index);
     let signing_key = key_manager_api.derive_key(key_manager::TRANSACTION_BRANCH, signing_key_index)?;
 
@@ -129,11 +124,6 @@ pub async fn handle_create(
     let transaction = Transaction::builder()
         .fee_transaction_pay_from_component(default_account.address.as_component_address().unwrap(), max_fee)
         .create_account(owner_pk.clone())
-        .with_input_refs(
-            input_refs
-                .iter()
-                .map(|s| SubstateRequirement::new(s.substate_id.clone(), Some(s.version))),
-        )
         .with_inputs(
             inputs
                 .iter()
@@ -954,7 +944,7 @@ pub async fn handle_transfer(
     let transaction = Transaction::builder()
         .with_fee_instructions(fee_instructions)
         .with_instructions(instructions)
-        .with_input_refs(vec![resource_substate_address])
+        .with_inputs(vec![resource_substate_address])
         .sign(&account_secret_key.key)
         .build();
 
diff --git a/applications/tari_dan_wallet_web_ui/src/routes/AssetVault/Components/SendMoney.tsx b/applications/tari_dan_wallet_web_ui/src/routes/AssetVault/Components/SendMoney.tsx
index 03f9f1c12..4bfde5c79 100644
--- a/applications/tari_dan_wallet_web_ui/src/routes/AssetVault/Components/SendMoney.tsx
+++ b/applications/tari_dan_wallet_web_ui/src/routes/AssetVault/Components/SendMoney.tsx
@@ -79,12 +79,12 @@ export function SendMoneyDialog(props: SendMoneyDialogProps) {
     outputToConfidential: false,
     inputSelection: "PreferRevealed",
     amount: "",
+    fee: "",
     badge: null,
   };
   const isConfidential = props.resource_type === "Confidential";
   const [useBadge, setUseBadge] = useState(false);
   const [disabled, setDisabled] = useState(false);
-  const [estimatedFee, setEstimatedFee] = useState(0);
   const [transferFormState, setTransferFormState] = useState(INITIAL_VALUES);
   const [validity, setValidity] = useState<object>({
     publicKey: false,
@@ -108,7 +108,8 @@ export function SendMoneyDialog(props: SendMoneyDialogProps) {
     // HACK: default to XTR2 because the resource is only set when open==true, and we cannot conditionally call hooks i.e. when props.resource_address is set
     props.resource_address || XTR2,
     transferFormState.publicKey,
-    estimatedFee,
+    parseInt(transferFormState.fee),
+    // estimatedFee,
     props.resource_type === "Confidential",
     !transferFormState.outputToConfidential,
     transferFormState.inputSelection as ConfidentialTransferInputSelection,
@@ -140,7 +141,6 @@ export function SendMoneyDialog(props: SendMoneyDialogProps) {
         [e.target.name]: e.target.validity.valid,
       });
     }
-    setEstimatedFee(0);
   }
 
   function setSelectFormValue(e: SelectChangeEvent<unknown>) {
@@ -148,7 +148,6 @@ export function SendMoneyDialog(props: SendMoneyDialogProps) {
       ...transferFormState,
       [e.target.name]: e.target.value,
     });
-    setEstimatedFee(0);
   }
 
   function setCheckboxFormValue(e: React.ChangeEvent<HTMLInputElement>) {
@@ -156,13 +155,12 @@ export function SendMoneyDialog(props: SendMoneyDialogProps) {
       ...transferFormState,
       [e.target.name]: e.target.checked,
     });
-    setEstimatedFee(0);
   }
 
   const onTransfer = async () => {
     if (accountName) {
       setDisabled(true);
-      if (estimatedFee) {
+      if (!isNaN(parseInt(transferFormState.fee))) {
         sendIt?.()
           .then(() => {
             setTransferFormState(INITIAL_VALUES);
@@ -187,7 +185,7 @@ export function SendMoneyDialog(props: SendMoneyDialogProps) {
               });
               return;
             }
-            setEstimatedFee(result.fee);
+            setTransferFormState({ ...transferFormState, fee: result.fee.toString() });
           })
           .catch((e) => {
             setPopup({ title: "Fee estimate failed", error: true, message: e.message });
@@ -303,10 +301,11 @@ export function SendMoneyDialog(props: SendMoneyDialogProps) {
           <TextField
             name="fee"
             label="Fee"
-            value={estimatedFee || "Press fee estimate to calculate"}
-            style={{ flexGrow: 1 }}
+            value={transferFormState.fee}
+            placeholder="Enter fee or press Estimate Fee to calculate"
+            onChange={setFormValue}
             disabled={disabled}
-            InputProps={{ readOnly: true }}
+            style={{ flexGrow: 1 }}
           />
           <Box
             className="flex-container"
@@ -318,7 +317,7 @@ export function SendMoneyDialog(props: SendMoneyDialogProps) {
               Cancel
             </Button>
             <Button variant="contained" type="submit" disabled={disabled || !allValid}>
-              {estimatedFee ? "Send" : "Estimate fee"}
+              {isNaN(parseInt(transferFormState.fee)) ? "Estimate fee" : "Send"}
             </Button>
           </Box>
         </Form>
diff --git a/applications/tari_indexer/src/dry_run/error.rs b/applications/tari_indexer/src/dry_run/error.rs
index 0a5877b26..b1e126316 100644
--- a/applications/tari_indexer/src/dry_run/error.rs
+++ b/applications/tari_indexer/src/dry_run/error.rs
@@ -22,6 +22,7 @@
 
 use tari_dan_app_utilities::transaction_executor::TransactionProcessorError;
 use tari_dan_common_types::{Epoch, SubstateAddress};
+use tari_dan_engine::state_store::StateStoreError;
 use tari_engine_types::substate::SubstateId;
 use tari_epoch_manager::EpochManagerError;
 use tari_indexer_lib::{error::IndexerError, transaction_autofiller::TransactionAutofillerError};
@@ -53,4 +54,6 @@ pub enum DryRunTransactionProcessorError {
     },
     #[error("Indexer error : {0}")]
     IndexerError(#[from] IndexerError),
+    #[error("StateStore error: {0}")]
+    StateStoreError(#[from] StateStoreError),
 }
diff --git a/applications/tari_indexer/src/dry_run/processor.rs b/applications/tari_indexer/src/dry_run/processor.rs
index 093f2e51d..5e5bf1c4b 100644
--- a/applications/tari_indexer/src/dry_run/processor.rs
+++ b/applications/tari_indexer/src/dry_run/processor.rs
@@ -115,8 +115,8 @@ where TSubstateCache: SubstateCache + 'static
 
         let virtual_substates = self.get_virtual_substates(&transaction, epoch).await?;
 
-        let mut state_store = new_state_store();
-        state_store.extend(found_substates);
+        let state_store = new_state_store();
+        state_store.set_many(found_substates)?;
 
         // execute the payload in the WASM engine and return the result
         let result = task::block_in_place(|| payload_processor.execute(transaction, state_store, virtual_substates))?;
@@ -155,13 +155,19 @@ where TSubstateCache: SubstateCache + 'static
     ) -> Result<HashMap<SubstateId, Substate>, DryRunTransactionProcessorError> {
         let mut substates = HashMap::new();
 
-        for address in transaction.inputs().iter().chain(transaction.input_refs()) {
+        // Fetch explicit inputs that may not have been resolved by the autofiller
+        for requirement in transaction.inputs() {
+            let Some(address) = requirement.to_substate_address() else {
+                // No version, we cant fetch it
+                continue;
+            };
             // If the input has been filled, we've already fetched the substate
-            if transaction.filled_inputs().contains(address) {
+            // Note: this works because VersionedSubstateId hashes the same as SubstateId internally.
+            if transaction.filled_inputs().contains(&requirement.substate_id) {
                 continue;
             }
 
-            let (id, substate) = self.fetch_substate(address.to_substate_address(), epoch).await?;
+            let (id, substate) = self.fetch_substate(address, epoch).await?;
             substates.insert(id, substate);
         }
 
diff --git a/applications/tari_indexer/src/json_rpc/handlers.rs b/applications/tari_indexer/src/json_rpc/handlers.rs
index 2190368c6..fa3072cfe 100644
--- a/applications/tari_indexer/src/json_rpc/handlers.rs
+++ b/applications/tari_indexer/src/json_rpc/handlers.rs
@@ -545,9 +545,31 @@ impl JsonRpcHandlers {
             }));
         }
 
+        // If there are no requested substates, we skip auto-filling altogether
+        let transaction = if request.required_substates.is_empty() {
+            request.transaction
+        } else {
+            // automatically scan the inputs and add all related involved objects
+            // note that this operation does not alter the transaction hash
+            self.transaction_manager
+                .autofill_transaction(request.transaction, request.required_substates)
+                .await
+                .map_err(|e| match e {
+                    TransactionManagerError::AllValidatorsFailed { .. } => JsonRpcResponse::error(
+                        answer_id,
+                        JsonRpcError::new(
+                            JsonRpcErrorReason::ApplicationError(400),
+                            format!("All validators failed: {}", e),
+                            json::Value::Null,
+                        ),
+                    ),
+                    e => Self::internal_error(answer_id, e),
+                })?
+        };
+
         let transaction_id = self
             .transaction_manager
-            .submit_transaction(request.transaction, request.required_substates)
+            .submit_transaction(transaction)
             .await
             .map_err(|e| match e {
                 TransactionManagerError::AllValidatorsFailed { .. } => JsonRpcResponse::error(
diff --git a/applications/tari_indexer/src/transaction_manager/mod.rs b/applications/tari_indexer/src/transaction_manager/mod.rs
index d985f36ef..d66750c27 100644
--- a/applications/tari_indexer/src/transaction_manager/mod.rs
+++ b/applications/tari_indexer/src/transaction_manager/mod.rs
@@ -76,41 +76,42 @@ where
         }
     }
 
-    pub async fn submit_transaction(
-        &self,
-        transaction: Transaction,
-        required_substates: Vec<SubstateRequirement>,
-    ) -> Result<TransactionId, TransactionManagerError> {
+    pub async fn submit_transaction(&self, transaction: Transaction) -> Result<TransactionId, TransactionManagerError> {
         let tx_hash = *transaction.id();
 
         info!(
             target: LOG_TARGET,
             "Submitting transaction with hash {} to the validator node", tx_hash
         );
-        // automatically scan the inputs and add all related involved objects
-        // note that this operation does not alter the transaction hash
-        let (autofilled_transaction, _) = self
-            .transaction_autofiller
-            .autofill_transaction(transaction, required_substates)
-            .await?;
-
         let transaction_substate_address = SubstateAddress::for_transaction_receipt(tx_hash.into_array().into());
 
-        if autofilled_transaction.involved_shards_iter().count() == 0 {
+        if transaction.involved_shards_iter().count() == 0 {
             self.try_with_committee(iter::once(transaction_substate_address), |mut client| {
-                let transaction = autofilled_transaction.clone();
+                let transaction = transaction.clone();
                 async move { client.submit_transaction(transaction).await }
             })
             .await
         } else {
-            self.try_with_committee(autofilled_transaction.involved_shards_iter(), |mut client| {
-                let transaction = autofilled_transaction.clone();
+            self.try_with_committee(transaction.involved_shards_iter(), |mut client| {
+                let transaction = transaction.clone();
                 async move { client.submit_transaction(transaction).await }
             })
             .await
         }
     }
 
+    pub async fn autofill_transaction(
+        &self,
+        transaction: Transaction,
+        required_substates: Vec<SubstateRequirement>,
+    ) -> Result<Transaction, TransactionManagerError> {
+        let (transaction, _) = self
+            .transaction_autofiller
+            .autofill_transaction(transaction, required_substates)
+            .await?;
+        Ok(transaction)
+    }
+
     pub async fn get_transaction_result(
         &self,
         transaction_id: TransactionId,
diff --git a/applications/tari_validator_node/src/bootstrap.rs b/applications/tari_validator_node/src/bootstrap.rs
index ee7bb60f6..de91c015c 100644
--- a/applications/tari_validator_node/src/bootstrap.rs
+++ b/applications/tari_validator_node/src/bootstrap.rs
@@ -93,7 +93,6 @@ use crate::{
                 FeeTransactionValidator,
                 HasInputs,
                 HasInvolvedShards,
-                InputRefsValidator,
                 MempoolError,
                 MempoolHandle,
                 OutputsDontExistLocally,
@@ -536,7 +535,5 @@ fn create_mempool_before_execute_validator(
 fn create_mempool_after_execute_validator<TAddr: NodeAddressable>(
     store: SqliteStateStore<TAddr>,
 ) -> impl Validator<ExecutedTransaction, Error = MempoolError> {
-    HasInvolvedShards::new()
-        .and_then(InputRefsValidator::new())
-        .and_then(OutputsDontExistLocally::new(store))
+    HasInvolvedShards::new().and_then(OutputsDontExistLocally::new(store))
 }
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 6694d36b3..f2f0d302f 100644
--- a/applications/tari_validator_node/src/consensus/block_transaction_executor.rs
+++ b/applications/tari_validator_node/src/consensus/block_transaction_executor.rs
@@ -1,8 +1,9 @@
 //   Copyright 2024 The Tari Project
 //   SPDX-License-Identifier: BSD-3-Clause
 
-use std::collections::{HashMap, HashSet};
+use std::collections::HashMap;
 
+use indexmap::IndexSet;
 use log::info;
 use tari_consensus::traits::{
     BlockTransactionExecutor,
@@ -15,10 +16,13 @@ use tari_dan_engine::{
     bootstrap_state,
     state_store::{memory::MemoryStateStore, AtomicDb, StateWriter},
 };
-use tari_dan_storage::{consensus_models::ExecutedTransaction, StateStore, StateStoreReadTransaction};
-use tari_engine_types::{commit_result::TransactionResult, substate::SubstateId, virtual_substate::VirtualSubstates};
+use tari_dan_storage::{
+    consensus_models::{ExecutedTransaction, SubstateLockFlag, SubstateRecord, VersionedSubstateIdLockIntent},
+    StateStore,
+};
+use tari_engine_types::{substate::SubstateId, virtual_substate::VirtualSubstates};
 use tari_epoch_manager::EpochManagerReader;
-use tari_transaction::{SubstateRequirement, Transaction};
+use tari_transaction::{Transaction, VersionedSubstateId};
 
 const LOG_TARGET: &str = "tari::dan::consensus::hotstuff::block_transaction_executor";
 
@@ -48,11 +52,10 @@ where
     TExecutor: TransactionExecutor + Clone + 'static,
     TEpochManager: EpochManagerReader + Clone + 'static,
 {
-    fn build(&self) -> Box<dyn BlockTransactionExecutor<TStateStore>> {
-        Box::new(TariDanBlockTransactionExecutor::new(
-            self.epoch_manager.clone(),
-            self.executor.clone(),
-        ))
+    type Executor = TariDanBlockTransactionExecutor<TEpochManager, TExecutor>;
+
+    fn build(&self) -> Self::Executor {
+        TariDanBlockTransactionExecutor::new(self.epoch_manager.clone(), self.executor.clone())
     }
 }
 
@@ -82,7 +85,7 @@ where
         let id: tari_transaction::TransactionId = *transaction.id();
 
         // Get the latest input substates
-        let inputs: HashSet<SubstateRequirement> = self.resolve_substates::<TStateStore>(&transaction, db_tx)?;
+        let inputs = self.resolve_substates::<TStateStore>(&transaction, db_tx)?;
         info!(target: LOG_TARGET, "Transaction {} executing. Inputs: {:?}", id, inputs);
 
         // Create a memory db with all the input substates, needed for the transaction execution
@@ -99,20 +102,33 @@ where
             .map_err(|e| BlockTransactionExecutorError::ExecutionThreadFailure(e.to_string()))?;
 
         // Store the output versions for future concurrent transactions in the same block
-        if let TransactionResult::Accept(diff) = &executed.result().finalize.result {
+        if let Some(diff) = executed.result().finalize.accept() {
             diff.up_iter().for_each(|s| {
                 self.output_versions.insert(s.0.clone(), s.1.version());
             });
         }
 
-        // Update the filled inputs to set the specific version, as we already know it after execution
-        let filled_inputs_mut = executed.transaction_mut().filled_inputs_mut();
-        inputs.into_iter().for_each(|input| {
-            filled_inputs_mut.push(input);
-        });
+        // Update the resolved inputs to set the specific version, as we know it after execution
+        let mut resolved_inputs = IndexSet::new();
+        if let Some(diff) = executed.result().finalize.accept() {
+            resolved_inputs = inputs
+                .into_iter()
+                .map(|versioned_id| {
+                    let lock_flag = if diff.down_iter().any(|(id, _)| *id == versioned_id.substate_id) {
+                        // Update all inputs that were DOWNed to be write locked
+                        SubstateLockFlag::Write
+                    } else {
+                        // Any input not downed, gets a read lock
+                        SubstateLockFlag::Read
+                    };
+                    VersionedSubstateIdLockIntent::new(versioned_id, lock_flag)
+                })
+                .collect::<IndexSet<_>>();
+        }
+
+        executed.set_resolved_inputs(resolved_inputs);
 
         info!(target: LOG_TARGET, "Transaction {} executed. result: {:?}", id, executed);
-
         Ok(executed)
     }
 }
@@ -130,49 +146,60 @@ impl<TEpochManager, TExecutor> TariDanBlockTransactionExecutor<TEpochManager, TE
         &self,
         transaction: &Transaction,
         db_tx: &mut <TStateStore as StateStore>::ReadTransaction<'_>,
-    ) -> Result<HashSet<SubstateRequirement>, BlockTransactionExecutorError> {
-        let mut resolved_substates = HashSet::new();
+    ) -> Result<IndexSet<VersionedSubstateId>, BlockTransactionExecutorError> {
+        let mut resolved_substates = IndexSet::with_capacity(transaction.num_unique_inputs());
         for input in transaction.all_inputs_iter() {
-            // We try to fetch each input from the block "cache", and only hit the DB if the input has not been used in
-            // the block before
-            let resolved_substate = match self.output_versions.get(input.substate_id()) {
-                Some(version) => SubstateRequirement::new(input.substate_id.clone(), Some(*version)),
-                None => self.resolve_local_substate::<TStateStore>(input.substate_id(), db_tx)?,
+            let address = match input.version() {
+                Some(version) => VersionedSubstateId::new(input.substate_id, version),
+                None => {
+                    // We try to fetch each input from the block "cache", and only hit the DB if the input has not been
+                    // used in the block before
+                    match self.output_versions.get(input.substate_id()) {
+                        Some(version) => VersionedSubstateId::new(input.substate_id, *version),
+                        None => self.resolve_local_substate::<TStateStore>(input.substate_id, db_tx)?,
+                    }
+                },
             };
-            resolved_substates.insert(resolved_substate);
+            resolved_substates.insert(address);
         }
-        // TODO: we assume local only transactions, we need to implement multi-shard transactions
+        // TODO: we assume local only transactions, we need to implement multi-shard transactions.
+        //       Suggest once we have pledges for foreign substates, we add them to a temporary pledge store and use
+        //       that to resolve inputs.
         Ok(resolved_substates)
     }
 
     fn resolve_local_substate<TStateStore: StateStore>(
         &self,
-        id: &SubstateId,
+        id: SubstateId,
         db_tx: &mut <TStateStore as StateStore>::ReadTransaction<'_>,
-    ) -> Result<SubstateRequirement, BlockTransactionExecutorError> {
-        let version = Self::get_last_substate_version::<TStateStore>(db_tx, id)
-            .ok_or(BlockTransactionExecutorError::PlaceHolderError)?;
-        Ok(SubstateRequirement::new(id.clone(), Some(version)))
+    ) -> Result<VersionedSubstateId, BlockTransactionExecutorError> {
+        let version = Self::get_last_substate_version::<TStateStore>(db_tx, &id)?.ok_or_else(|| {
+            BlockTransactionExecutorError::UnableToResolveSubstateId {
+                substate_id: id.clone(),
+            }
+        })?;
+        Ok(VersionedSubstateId::new(id, version))
     }
 
     fn add_substates_to_memory_db<TStateStore: StateStore>(
         &self,
         db_tx: &mut <TStateStore as StateStore>::ReadTransaction<'_>,
-        inputs: &HashSet<SubstateRequirement>,
+        inputs: &IndexSet<VersionedSubstateId>,
         out: &MemoryStateStore,
     ) -> Result<(), BlockTransactionExecutorError> {
-        let mut substates = vec![];
+        let mut access = out
+            .write_access()
+            .map_err(|e| BlockTransactionExecutorError::StateStoreError(e.to_string()))?;
         for input in inputs {
             let address = input.to_substate_address();
-            let substate = db_tx.substates_get(&address)?;
-            substates.push(substate);
+            let substate = SubstateRecord::get(db_tx, &address)?;
+            access
+                .set_state(&input.substate_id, substate.into_substate())
+                .map_err(|e| BlockTransactionExecutorError::StateStoreError(e.to_string()))?;
         }
-
-        out.set_all(
-            substates
-                .into_iter()
-                .map(|s| (s.substate_id.clone(), s.into_substate())),
-        );
+        access
+            .commit()
+            .map_err(|e| BlockTransactionExecutorError::StateStoreError(e.to_string()))?;
 
         Ok(())
     }
@@ -180,24 +207,18 @@ impl<TEpochManager, TExecutor> TariDanBlockTransactionExecutor<TEpochManager, TE
     fn get_last_substate_version<TStateStore: StateStore>(
         db_tx: &mut <TStateStore as StateStore>::ReadTransaction<'_>,
         substate_id: &SubstateId,
-    ) -> Option<u32> {
-        // TODO: store in DB the substate_id and version so we can just fetch the latest one and we don't have to loop
-        // from 0
+    ) -> Result<Option<u32>, BlockTransactionExecutorError> {
+        // TODO: add a DB query to fetch the latest version
         let mut version = 0;
         loop {
             let address = SubstateAddress::from_address(substate_id, version);
             info!(target: LOG_TARGET, "get_last_substate_version {}:{}, address: {}", substate_id, version, address);
-            match db_tx.substates_get(&address) {
-                Ok(_) => {
-                    version += 1;
-                },
-                Err(_) => {
-                    if version > 0 {
-                        return Some(version - 1);
-                    } else {
-                        return None;
-                    }
-                },
+            if SubstateRecord::exists(db_tx, &address)? {
+                version += 1;
+            } else if version > 0 {
+                return Ok(Some(version - 1));
+            } else {
+                return Ok(None);
             }
         }
     }
diff --git a/applications/tari_validator_node/src/consensus/metrics.rs b/applications/tari_validator_node/src/consensus/metrics.rs
index 990cc9092..9d9cddd9d 100644
--- a/applications/tari_validator_node/src/consensus/metrics.rs
+++ b/applications/tari_validator_node/src/consensus/metrics.rs
@@ -196,6 +196,7 @@ impl<S: StateStore> ConsensusHooks for PrometheusConsensusMetrics<S> {
             Decision::Abort => {
                 self.transactions_finalized_aborted.inc();
             },
+            Decision::Deferred => {},
         }
     }
 }
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 6f455b4c9..4ddaad7f7 100644
--- a/applications/tari_validator_node/src/dry_run_transaction_processor.rs
+++ b/applications/tari_validator_node/src/dry_run_transaction_processor.rs
@@ -118,7 +118,8 @@ impl DryRunTransactionProcessor {
             .resolve_virtual_substates(&transaction, current_epoch)
             .await?;
 
-        self.substate_resolver.resolve(&transaction, &temp_state_store).await?;
+        let inputs = self.substate_resolver.resolve(&transaction).await?;
+        temp_state_store.set_many(inputs)?;
 
         // execute the payload in the WASM engine and return the result
         let executed = task::block_in_place(|| {
diff --git a/applications/tari_validator_node/src/json_rpc/handlers.rs b/applications/tari_validator_node/src/json_rpc/handlers.rs
index 1ce31c3e8..fa328d78d 100644
--- a/applications/tari_validator_node/src/json_rpc/handlers.rs
+++ b/applications/tari_validator_node/src/json_rpc/handlers.rs
@@ -162,9 +162,20 @@ impl JsonRpcHandlers {
             target: LOG_TARGET,
             "Transaction {} has {} involved shards",
             transaction.hash(),
-            transaction.num_involved_shards()
+            transaction.num_unique_inputs()
         );
 
+        if !transaction.check_id() {
+            return Err(JsonRpcResponse::error(
+                answer_id,
+                JsonRpcError::new(
+                    JsonRpcErrorReason::InvalidParams,
+                    "Transaction ID is invalid".to_string(),
+                    json!(null),
+                ),
+            ));
+        }
+
         let tx_id = *transaction.id();
 
         if is_dry_run {
diff --git a/applications/tari_validator_node/src/p2p/services/mempool/error.rs b/applications/tari_validator_node/src/p2p/services/mempool/error.rs
index 0af7f0c65..059d93585 100644
--- a/applications/tari_validator_node/src/p2p/services/mempool/error.rs
+++ b/applications/tari_validator_node/src/p2p/services/mempool/error.rs
@@ -47,8 +47,6 @@ pub enum MempoolError {
     InvalidTemplateAddress(#[from] TemplateManagerError),
     #[error("No fee instructions")]
     NoFeeInstructions,
-    #[error("Input refs downed")]
-    InputRefsDowned,
     #[error("Output substate exists in transaction {transaction_id}")]
     OutputSubstateExists { transaction_id: TransactionId },
     #[error("Validator fee claim instruction in transaction {transaction_id} contained invalid epoch {given_epoch}")]
diff --git a/applications/tari_validator_node/src/p2p/services/mempool/executor.rs b/applications/tari_validator_node/src/p2p/services/mempool/executor.rs
index e5a6baaad..4fcfe474d 100644
--- a/applications/tari_validator_node/src/p2p/services/mempool/executor.rs
+++ b/applications/tari_validator_node/src/p2p/services/mempool/executor.rs
@@ -1,6 +1,7 @@
 //    Copyright 2023 The Tari Project
 //    SPDX-License-Identifier: BSD-3-Clause
 
+use indexmap::IndexSet;
 use log::*;
 use tari_dan_app_utilities::transaction_executor::{TransactionExecutor, TransactionProcessorError};
 use tari_dan_common_types::Epoch;
@@ -8,8 +9,8 @@ use tari_dan_engine::{
     bootstrap_state,
     state_store::{memory::MemoryStateStore, AtomicDb, StateWriter},
 };
-use tari_dan_storage::consensus_models::ExecutedTransaction;
-use tari_transaction::{Transaction, TransactionId};
+use tari_dan_storage::consensus_models::{ExecutedTransaction, SubstateLockFlag, VersionedSubstateIdLockIntent};
+use tari_transaction::{Transaction, VersionedSubstateId};
 use tokio::task;
 
 use crate::{
@@ -19,21 +20,16 @@ use crate::{
 
 const LOG_TARGET: &str = "tari::dan::mempool::executor";
 
-pub(super) type ExecutionResult = (TransactionId, Result<ExecutedTransaction, MempoolError>);
-
 pub async fn execute_transaction<TSubstateResolver, TExecutor>(
     transaction: Transaction,
     substate_resolver: TSubstateResolver,
     executor: TExecutor,
     current_epoch: Epoch,
-) -> Result<ExecutionResult, MempoolError>
+) -> Result<Result<ExecutedTransaction, MempoolError>, MempoolError>
 where
     TSubstateResolver: SubstateResolver<Error = SubstateResolverError>,
     TExecutor: TransactionExecutor<Error = TransactionProcessorError> + Send + Sync + 'static,
 {
-    let id = *transaction.id();
-
-    let state_db = new_state_db();
     let virtual_substates = match substate_resolver
         .resolve_virtual_substates(&transaction, current_epoch)
         .await
@@ -41,18 +37,60 @@ where
         Ok(virtual_substates) => virtual_substates,
         Err(err @ SubstateResolverError::UnauthorizedFeeClaim { .. }) => {
             warn!(target: LOG_TARGET, "One or more invalid fee claims for transaction {}: {}", transaction.id(), err);
-            return Ok((*transaction.id(), Err(err.into())));
+            return Ok(Err(err.into()));
         },
         Err(err) => return Err(err.into()),
     };
 
     info!(target: LOG_TARGET, "Transaction {} executing. virtual_substates = [{}]", transaction.id(), virtual_substates.keys().map(|addr| addr.to_string()).collect::<Vec<_>>().join(", "));
 
-    match substate_resolver.resolve(&transaction, &state_db).await {
-        Ok(()) => {
+    match substate_resolver.resolve(&transaction).await {
+        Ok(inputs) => {
             let res = task::spawn_blocking(move || {
-                let result = executor.execute(transaction, state_db, virtual_substates);
-                (id, result.map_err(MempoolError::from))
+                let versioned_inputs = inputs
+                    .iter()
+                    .map(|(id, substate)| VersionedSubstateId::new(id.clone(), substate.version()))
+                    .collect::<IndexSet<_>>();
+                let state_db = new_state_db();
+                state_db.set_many(inputs).expect("memory db is infallible");
+
+                match executor.execute(transaction, state_db, virtual_substates) {
+                    Ok(mut executed) => {
+                        // TODO: refactor executor so that resolved inputs are set internally
+                        // Update the resolved inputs to set the specific version, as we know it after execution
+                        if let Some(diff) = executed.result().finalize.accept() {
+                            let resolved_inputs = versioned_inputs
+                                .into_iter()
+                                .map(|versioned_id| {
+                                    let lock_flag = if diff.down_iter().any(|(id, _)| *id == versioned_id.substate_id) {
+                                        // Update all inputs that were DOWNed to be write locked
+                                        SubstateLockFlag::Write
+                                    } else {
+                                        // Any input not downed, gets a read lock
+                                        SubstateLockFlag::Read
+                                    };
+                                    VersionedSubstateIdLockIntent::new(versioned_id, lock_flag)
+                                })
+                                .collect::<IndexSet<_>>();
+                            executed.set_resolved_inputs(resolved_inputs);
+                        } else {
+                            let resolved_inputs = versioned_inputs
+                                .into_iter()
+                                .map(|versioned_id| {
+                                    // We cannot tell which inputs are written, however since this transaction is a
+                                    // reject it does not matter since it will not cause locks.
+                                    // We still set resolved inputs because this is used to determine which shards are
+                                    // involved.
+                                    VersionedSubstateIdLockIntent::new(versioned_id, SubstateLockFlag::Write)
+                                })
+                                .collect::<IndexSet<_>>();
+                            executed.set_resolved_inputs(resolved_inputs);
+                        }
+
+                        Ok(executed)
+                    },
+                    Err(err) => Err(err.into()),
+                }
             })
             .await;
 
@@ -63,7 +101,8 @@ where
         Err(err @ SubstateResolverError::InputSubstateDowned { .. }) |
         Err(err @ SubstateResolverError::InputSubstateDoesNotExist { .. }) => {
             warn!(target: LOG_TARGET, "One or more invalid input shards for transaction {}: {}", transaction.id(), err);
-            Ok((*transaction.id(), Err(err.into())))
+            // Ok(Err(_)) This is not a mempool execution failure, but rather a transaction failure
+            Ok(Err(err.into()))
         },
         // Some other issue - network, db, etc
         Err(err) => Err(err.into()),
diff --git a/applications/tari_validator_node/src/p2p/services/mempool/service.rs b/applications/tari_validator_node/src/p2p/services/mempool/service.rs
index fbe11928c..4e268f51a 100644
--- a/applications/tari_validator_node/src/p2p/services/mempool/service.rs
+++ b/applications/tari_validator_node/src/p2p/services/mempool/service.rs
@@ -20,7 +20,7 @@
 //   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::HashSet, fmt::Display, iter, ops::DerefMut, time::Duration};
+use std::{collections::HashSet, fmt::Display, iter, ops::DerefMut};
 
 use futures::{future::BoxFuture, stream::FuturesUnordered, FutureExt, StreamExt};
 use log::*;
@@ -28,14 +28,9 @@ use tari_dan_app_utilities::transaction_executor::{TransactionExecutor, Transact
 use tari_dan_common_types::{optional::Optional, shard::Shard, Epoch, PeerAddress, SubstateAddress};
 use tari_dan_p2p::{DanMessage, NewTransactionMessage};
 use tari_dan_storage::{
-    consensus_models::{ExecutedTransaction, SubstateRecord, TransactionPool, TransactionRecord},
+    consensus_models::{ExecutedTransaction, SubstateRecord, TransactionRecord},
     StateStore,
 };
-use tari_engine_types::{
-    commit_result::{ExecuteResult, FinalizeResult, TransactionResult},
-    fees::FeeReceipt,
-    substate::SubstateDiff,
-};
 use tari_epoch_manager::{base_layer::EpochManagerHandle, EpochManagerEvent, EpochManagerReader};
 use tari_state_store_sqlite::SqliteStateStore;
 use tari_transaction::{Transaction, TransactionId};
@@ -48,7 +43,7 @@ use crate::{
     consensus::ConsensusHandle,
     p2p::services::{
         mempool::{
-            executor::{execute_transaction, ExecutionResult},
+            executor::execute_transaction,
             gossip::MempoolGossip,
             handle::MempoolRequest,
             traits::SubstateResolver,
@@ -63,11 +58,26 @@ const LOG_TARGET: &str = "tari::validator_node::mempool::service";
 
 /// Data returned from a pending execution.
 struct MempoolTransactionExecution {
-    result: Result<ExecutionResult, MempoolError>,
+    transaction_id: TransactionId,
+    execution: TransactionExecution,
     should_propagate: bool,
     sender_shard: Option<Shard>,
 }
 
+pub enum TransactionExecution {
+    /// The transaction was executed in the mempool
+    Executed {
+        result: Result<ExecutedTransaction, MempoolError>,
+    },
+    /// Mempool execution failed due to an error that is unrelated to the transaction. IO, resources, database etc
+    ExecutionFailure {
+        error: MempoolError,
+        transaction: Transaction,
+    },
+    /// Execution cannot occur in the mempool and is deferred to consensus
+    Deferred { transaction: Transaction },
+}
+
 #[derive(Debug)]
 pub struct MempoolService<TValidator, TExecutedValidator, TExecutor, TSubstateResolver> {
     transactions: HashSet<TransactionId>,
@@ -80,7 +90,6 @@ pub struct MempoolService<TValidator, TExecutedValidator, TExecutor, TSubstateRe
     transaction_executor: TExecutor,
     substate_resolver: TSubstateResolver,
     state_store: SqliteStateStore<PeerAddress>,
-    transaction_pool: TransactionPool<SqliteStateStore<PeerAddress>>,
     gossip: MempoolGossip<PeerAddress>,
     rx_consensus_to_mempool: mpsc::UnboundedReceiver<Transaction>,
     consensus_handle: ConsensusHandle,
@@ -122,7 +131,6 @@ where
             before_execute_validator,
             after_execute_validator,
             state_store,
-            transaction_pool: TransactionPool::new(),
             rx_consensus_to_mempool,
             consensus_handle,
             #[cfg(feature = "metrics")]
@@ -137,7 +145,7 @@ where
             tokio::select! {
                 Some(req) = self.mempool_requests.recv() => self.handle_request(req).await,
                 Some(result) = self.pending_executions.next() => {
-                    if  let Err(e) = self.handle_execution_complete(result).await {
+                    if  let Err(e) = self.handle_execution_task_complete(result).await {
                         error!(target: LOG_TARGET, "Possible bug: handle_execution_complete failed: {}", e);
                     }
                 },
@@ -274,10 +282,11 @@ where
             };
             let mut is_input_shard = transaction
                 .all_inputs_iter()
-                .any(|s| s.to_committee_shard(num_committees) == sender_shard);
+                .filter_map(|s| s.to_committee_shard(num_committees))
+                .any(|s| s == sender_shard);
             // Special temporary case: if there are no input shards an output shard will also propagate. No inputs is
             // invalid, however we must support them for now because of CreateFreeTestCoin transactions.
-            is_input_shard |= transaction.inputs().len() + transaction.input_refs().len() == 0;
+            is_input_shard |= transaction.inputs().is_empty() && transaction.filled_inputs().is_empty();
             if !is_input_shard {
                 warn!(target: LOG_TARGET, "Sender {from} sent a message with output shards but was not an input shard. Ignoring message.");
                 return Ok(());
@@ -329,7 +338,7 @@ where
             validator_nodes.values().map(|vn| vn.shard_key).collect::<HashSet<_>>()
         };
 
-        if transaction.num_involved_shards() == 0 && claim_shards.is_empty() && unverified_output_shards.is_empty() {
+        if transaction.num_unique_inputs() == 0 && claim_shards.is_empty() && unverified_output_shards.is_empty() {
             warn!(target: LOG_TARGET, "⚠ No involved shards for payload");
         }
 
@@ -337,11 +346,11 @@ where
         let tx_substate_address = SubstateAddress::for_transaction_receipt(transaction.id().into_receipt_address());
 
         let local_committee_shard = self.epoch_manager.get_local_committee_shard(current_epoch).await?;
-        let transaction_inputs = transaction.all_inputs_iter().map(|i| i.to_substate_address());
+        let transaction_inputs = transaction.all_inputs_iter().filter_map(|i| i.to_substate_address());
         let mut is_input_shard = local_committee_shard.includes_any_shard(transaction_inputs);
         // Special temporary case: if there are no input shards an output shard will also propagate. No inputs is
         // invalid, however we must support them for now because of CreateFreeTestCoin transactions.
-        is_input_shard |= transaction.inputs().len() + transaction.input_refs().len() == 0;
+        is_input_shard |= transaction.inputs().is_empty() && transaction.filled_inputs().is_empty();
         let is_output_shard = local_committee_shard.includes_any_shard(
             // Known output shards
             // This is to allow for the txreceipt output
@@ -357,8 +366,22 @@ where
             // The transactions has one or more of its inputs with no version
             // This means we skip transaction execution in the mempool, as the execution will happen on consensus
             if transaction.has_inputs_without_version() {
-                self.handle_no_version_transaction(&transaction, should_propagate, sender_shard)
-                    .await?;
+                info!(
+                    target: LOG_TARGET,
+                    "✅ Transaction {} has inputs without versions. Execution is deferred to consensus to allow input substates to be resolved",
+                    transaction.id(),
+                );
+
+                let result = MempoolTransactionExecution {
+                    transaction_id: *transaction.id(),
+                    execution: TransactionExecution::Deferred {
+                        transaction: transaction.clone(),
+                    },
+                    should_propagate,
+                    sender_shard,
+                };
+
+                self.handle_execution_task_complete(result).await?;
             } else {
                 // All the inputs in the transaction have specific versions, so we execute immediately
                 self.queue_transaction_for_execution(
@@ -449,40 +472,6 @@ where
         Ok(())
     }
 
-    async fn handle_no_version_transaction(
-        &mut self,
-        transaction: &Transaction,
-        should_propagate: bool,
-        sender_shard: Option<Shard>,
-    ) -> Result<(), MempoolError> {
-        // TODO: for now we just skip execution, we may want to store the transaction in a new DB table
-        // TODO: do we need some sort of validation at this stage?
-
-        info!(
-            target: LOG_TARGET,
-            "✅ Transaction {} has inputs without versions, it goes directly to consensus",
-            transaction.id(),
-        );
-
-        let finalize = FinalizeResult::new(
-            transaction.hash(),
-            vec![],
-            vec![],
-            TransactionResult::Accept(SubstateDiff::new()),
-            FeeReceipt::default(),
-        );
-        let executed_transaction =
-            ExecutedTransaction::new(transaction.clone(), ExecuteResult { finalize }, vec![], Duration::ZERO);
-        let execution_result = (*transaction.id(), Ok(executed_transaction));
-        let result = MempoolTransactionExecution {
-            result: Ok(execution_result),
-            should_propagate,
-            sender_shard,
-        };
-
-        self.handle_execution_complete(result).await
-    }
-
     fn queue_transaction_for_execution(
         &mut self,
         transaction: Transaction,
@@ -492,28 +481,95 @@ where
     ) {
         let substate_resolver = self.substate_resolver.clone();
         let executor = self.transaction_executor.clone();
+        let transaction_id = *transaction.id();
 
         self.pending_executions.push(Box::pin(
-            execute_transaction(transaction, substate_resolver, executor, current_epoch).map(move |result| {
-                MempoolTransactionExecution {
-                    result,
-                    should_propagate,
-                    sender_shard,
+            execute_transaction(transaction.clone(), substate_resolver, executor, current_epoch).map(move |result| {
+                match result {
+                    Ok(execution_result) => MempoolTransactionExecution {
+                        transaction_id,
+                        execution: TransactionExecution::Executed {
+                            result: execution_result,
+                        },
+                        should_propagate,
+                        sender_shard,
+                    },
+                    Err(error) => MempoolTransactionExecution {
+                        transaction_id,
+                        // IO, Database, etc errors
+                        execution: TransactionExecution::ExecutionFailure { error, transaction },
+                        should_propagate,
+                        sender_shard,
+                    },
                 }
             }),
         ));
     }
 
-    #[allow(clippy::too_many_lines)]
-    async fn handle_execution_complete(&mut self, result: MempoolTransactionExecution) -> Result<(), MempoolError> {
+    async fn handle_execution_task_complete(
+        &mut self,
+        result: MempoolTransactionExecution,
+    ) -> Result<(), MempoolError> {
         let MempoolTransactionExecution {
-            result,
+            transaction_id,
+            execution,
             should_propagate,
             sender_shard,
         } = result;
-        // This is due to a bug or possibly db failure only
-        let (transaction_id, exec_result) = result?;
 
+        match execution {
+            TransactionExecution::Executed { result } => {
+                self.handle_execution_complete(transaction_id, result, should_propagate, sender_shard)
+                    .await
+            },
+            // Bubble the error up
+            TransactionExecution::ExecutionFailure { error, .. } => {
+                // TODO: should we retry this transaction at some point?
+                self.transactions.remove(&transaction_id);
+                Err(error)
+            },
+            TransactionExecution::Deferred { transaction } => self.handle_deferred_execution(transaction).await,
+        }
+    }
+
+    async fn handle_deferred_execution(&mut self, transaction: Transaction) -> Result<(), MempoolError> {
+        let transaction_id = *transaction.id();
+
+        // TODO: allow deferred transactions - this just rejects the transaction immediately
+        self.state_store.with_write_tx(|tx| {
+            TransactionRecord::get(tx.deref_mut(), &transaction_id)?
+                .set_abort("Transaction requires deferred execution but that is not currently supported")
+                .update(tx)
+        })?;
+
+        // let is_consensus_running = self.consensus_handle.get_current_state().is_running();
+        //
+        // let pending_exec_size = self.pending_executions.len();
+        // if is_consensus_running &&
+        //     // Notify consensus about the transaction
+        //     self.tx_executed_transactions
+        //         .send((transaction_id, pending_exec_size))
+        //         .await
+        //         .is_err()
+        // {
+        //     debug!(
+        //         target: LOG_TARGET,
+        //         "Executed transaction channel closed before executed transaction could be sent"
+        //     );
+        // }
+
+        self.transactions.remove(&transaction_id);
+        Ok(())
+    }
+
+    #[allow(clippy::too_many_lines)]
+    async fn handle_execution_complete(
+        &mut self,
+        transaction_id: TransactionId,
+        exec_result: Result<ExecutedTransaction, MempoolError>,
+        should_propagate: bool,
+        sender_shard: Option<Shard>,
+    ) -> Result<(), MempoolError> {
         #[cfg(feature = "metrics")]
         self.metrics.on_transaction_executed(&transaction_id, &exec_result);
 
@@ -522,6 +578,8 @@ where
         // 2. The node switches to sync mode
         // 3. Sync completes (some transactions that were finalized in sync may have been busy executing)
         // 4. Execution completes and the transaction is added to the pool even though it is finalized via sync
+        // TODO: This is not guaranteed to work and is subject to races. The mempool should pause processing executed
+        // transactions until consensus is in sync.
         if self
             .state_store
             .with_read_tx(|tx| SubstateRecord::exists_for_transaction(tx, &transaction_id))?
@@ -545,7 +603,7 @@ where
                     executed.result().finalize.result,
                     executed.execution_time()
                 );
-                let has_involved_shards = executed.num_involved_shards() > 0;
+                let has_involved_shards = executed.num_inputs_and_outputs() > 0;
 
                 match self.after_execute_validator.validate(&executed).await {
                     Ok(_) => {
@@ -570,12 +628,9 @@ where
                                 return Ok::<_, MempoolError>(());
                             }
 
+                            log::error!(target: LOG_TARGET, "🐞 resolved inputs: {:?}", executed.resolved_inputs());
+                            assert!(executed.resolved_inputs().is_some(), "Resolved inputs must be set");
                             executed.update(tx)?;
-                            if is_consensus_running &&
-                                !SubstateRecord::exists_for_transaction(tx.deref_mut(), &transaction_id)?
-                            {
-                                self.transaction_pool.insert(tx, executed.to_atom())?;
-                            }
                             Ok::<_, MempoolError>(())
                         })?;
                     },
@@ -602,12 +657,6 @@ where
                                 },
                             }
 
-                            if has_involved_shards &&
-                                is_consensus_running &&
-                                !SubstateRecord::exists_for_transaction(tx.deref_mut(), &transaction_id)?
-                            {
-                                self.transaction_pool.insert(tx, executed.to_atom())?;
-                            }
                             Ok::<_, MempoolError>(())
                         })?;
                         // We want this to go though to consensus, because validation may only fail in this shard (e.g
@@ -651,23 +700,20 @@ where
 
         let current_epoch = self.epoch_manager.current_epoch().await?;
 
-        self.epoch_manager.get_local_committee_shard(current_epoch).await?;
         let local_committee_shard = self.epoch_manager.get_local_committee_shard(current_epoch).await?;
-        let all_inputs_iter = executed
-            .transaction()
-            .all_inputs_iter()
-            .map(|i| i.to_substate_address());
+        let all_inputs_iter = executed.all_inputs_iter().map(|i| i.to_substate_address());
         let is_input_shard = local_committee_shard.includes_any_shard(all_inputs_iter) |
-            (executed.transaction().inputs().len() + executed.transaction().input_refs().len() == 0);
+            (executed.transaction().inputs().is_empty() && executed.transaction().filled_inputs().is_empty());
 
         if should_propagate && is_input_shard {
             // Forward the transaction to any output shards that are not part of the input shard set as these have
             // already been forwarded
             let num_committees = self.epoch_manager.get_num_committees(current_epoch).await?;
-            let input_shards: HashSet<Shard> = executed
-                .transaction()
-                .all_inputs_iter()
-                .map(|s| s.to_committee_shard(num_committees))
+            let input_shards = executed
+                .resolved_inputs()
+                .into_iter()
+                .flatten()
+                .map(|s| s.versioned_substate_id().to_committee_shard(num_committees))
                 .collect::<HashSet<_>>();
             let tx_substate_address = SubstateAddress::for_transaction_receipt(executed.id().into_receipt_address());
             let output_shards = executed
diff --git a/applications/tari_validator_node/src/p2p/services/mempool/traits.rs b/applications/tari_validator_node/src/p2p/services/mempool/traits.rs
index dc4b7c4e2..94f382288 100644
--- a/applications/tari_validator_node/src/p2p/services/mempool/traits.rs
+++ b/applications/tari_validator_node/src/p2p/services/mempool/traits.rs
@@ -2,16 +2,19 @@
 //    SPDX-License-Identifier: BSD-3-Clause
 
 use async_trait::async_trait;
+use indexmap::IndexMap;
 use tari_dan_common_types::Epoch;
-use tari_dan_engine::state_store::memory::MemoryStateStore;
-use tari_engine_types::virtual_substate::VirtualSubstates;
+use tari_engine_types::{
+    substate::{Substate, SubstateId},
+    virtual_substate::VirtualSubstates,
+};
 use tari_transaction::Transaction;
 
 #[async_trait]
 pub trait SubstateResolver {
     type Error: Send + Sync + 'static;
 
-    async fn resolve(&self, transaction: &Transaction, out: &MemoryStateStore) -> Result<(), Self::Error>;
+    async fn resolve(&self, transaction: &Transaction) -> Result<IndexMap<SubstateId, Substate>, Self::Error>;
 
     async fn resolve_virtual_substates(
         &self,
diff --git a/applications/tari_validator_node/src/p2p/services/mempool/validators/after/has_involved_shards.rs b/applications/tari_validator_node/src/p2p/services/mempool/validators/after/has_involved_shards.rs
index 10ad045a9..da48cd9a3 100644
--- a/applications/tari_validator_node/src/p2p/services/mempool/validators/after/has_involved_shards.rs
+++ b/applications/tari_validator_node/src/p2p/services/mempool/validators/after/has_involved_shards.rs
@@ -25,7 +25,7 @@ impl Validator<ExecutedTransaction> for HasInvolvedShards {
     type Error = MempoolError;
 
     async fn validate(&self, executed: &ExecutedTransaction) -> Result<(), Self::Error> {
-        if executed.num_involved_shards() == 0 {
+        if executed.num_inputs_and_outputs() == 0 {
             debug!(target: LOG_TARGET, "HasInvolvedShards - FAIL: No input or output shards");
             return Err(MempoolError::NoInvolvedShards {
                 transaction_id: *executed.id(),
diff --git a/applications/tari_validator_node/src/p2p/services/mempool/validators/after/input_refs.rs b/applications/tari_validator_node/src/p2p/services/mempool/validators/after/input_refs.rs
deleted file mode 100644
index 21f850470..000000000
--- a/applications/tari_validator_node/src/p2p/services/mempool/validators/after/input_refs.rs
+++ /dev/null
@@ -1,39 +0,0 @@
-//    Copyright 2023 The Tari Project
-//    SPDX-License-Identifier: BSD-3-Clause
-
-use async_trait::async_trait;
-use tari_dan_storage::consensus_models::ExecutedTransaction;
-use tari_transaction::SubstateRequirement;
-
-use crate::p2p::services::mempool::{MempoolError, Validator};
-
-/// Refuse to process the transaction if any input_refs are downed
-pub struct InputRefsValidator;
-
-impl InputRefsValidator {
-    pub fn new() -> Self {
-        Self
-    }
-}
-
-#[async_trait]
-impl Validator<ExecutedTransaction> for InputRefsValidator {
-    type Error = MempoolError;
-
-    async fn validate(&self, executed: &ExecutedTransaction) -> Result<(), Self::Error> {
-        let Some(diff) = executed.result().finalize.result.accept() else {
-            return Ok(());
-        };
-
-        let is_input_refs_downed = diff
-            .down_iter()
-            .map(|(s, v)| SubstateRequirement::new(s.clone(), Some(*v)))
-            .any(|s| executed.transaction().input_refs().contains(&s));
-
-        if is_input_refs_downed {
-            return Err(MempoolError::InputRefsDowned);
-        }
-
-        Ok(())
-    }
-}
diff --git a/applications/tari_validator_node/src/p2p/services/mempool/validators/after/mod.rs b/applications/tari_validator_node/src/p2p/services/mempool/validators/after/mod.rs
index 09be00b9c..f1c3cba3d 100644
--- a/applications/tari_validator_node/src/p2p/services/mempool/validators/after/mod.rs
+++ b/applications/tari_validator_node/src/p2p/services/mempool/validators/after/mod.rs
@@ -1,9 +1,7 @@
 //   Copyright 2023 The Tari Project
 //   SPDX-License-Identifier: BSD-3-Clause
 mod has_involved_shards;
-mod input_refs;
 mod outputs_dont_exist_locally;
 
 pub use has_involved_shards::*;
-pub use input_refs::*;
 pub use outputs_dont_exist_locally::*;
diff --git a/applications/tari_validator_node/src/substate_resolver.rs b/applications/tari_validator_node/src/substate_resolver.rs
index 5246964ba..bdb8e4d8d 100644
--- a/applications/tari_validator_node/src/substate_resolver.rs
+++ b/applications/tari_validator_node/src/substate_resolver.rs
@@ -4,14 +4,15 @@
 use std::{collections::HashSet, time::Instant};
 
 use async_trait::async_trait;
+use indexmap::IndexMap;
 use log::*;
 use tari_common_types::types::PublicKey;
 use tari_dan_common_types::{Epoch, SubstateAddress};
-use tari_dan_engine::state_store::memory::MemoryStateStore;
+use tari_dan_engine::state_store::StateStoreError;
 use tari_dan_storage::{consensus_models::SubstateRecord, StateStore, StorageError};
 use tari_engine_types::{
     instruction::Instruction,
-    substate::SubstateId,
+    substate::{Substate, SubstateId},
     virtual_substate::{VirtualSubstate, VirtualSubstateId, VirtualSubstates},
 };
 use tari_epoch_manager::{EpochManagerError, EpochManagerReader};
@@ -59,7 +60,7 @@ where
     fn resolve_local_substates(
         &self,
         transaction: &Transaction,
-        out: &MemoryStateStore,
+        out: &mut IndexMap<SubstateId, Substate>,
     ) -> Result<HashSet<SubstateAddress>, SubstateResolverError> {
         let inputs = transaction.all_input_addresses_iter();
         let (local_substates, missing_shards) = self.store.with_read_tx(|tx| SubstateRecord::get_any(tx, inputs))?;
@@ -70,7 +71,7 @@ where
             local_substates.len(),
             missing_shards.len());
 
-        out.set_all(
+        out.extend(
             local_substates
                 .into_iter()
                 .map(|s| (s.substate_id.clone(), s.into_substate())),
@@ -82,9 +83,9 @@ where
     async fn resolve_remote_substates(
         &self,
         substate_addresses: HashSet<SubstateAddress>,
-        out: &MemoryStateStore,
+        out: &mut IndexMap<SubstateId, Substate>,
     ) -> Result<(), SubstateResolverError> {
-        let mut retrieved_substates = Vec::with_capacity(substate_addresses.len());
+        out.reserve(substate_addresses.len());
         for substate_address in substate_addresses {
             let timer = Instant::now();
             let substate_result = self
@@ -100,7 +101,7 @@ where
                         id,
                         timer.elapsed().as_millis()
                     );
-                    retrieved_substates.push((id, substate));
+                    out.insert(id, substate);
                 },
                 SubstateResult::Down { id, version, .. } => {
                     return Err(SubstateResolverError::InputSubstateDowned { id, version });
@@ -113,8 +114,6 @@ where
             }
         }
 
-        out.set_all(retrieved_substates);
-
         Ok(())
     }
 
@@ -159,15 +158,17 @@ where
 {
     type Error = SubstateResolverError;
 
-    async fn resolve(&self, transaction: &Transaction, out: &MemoryStateStore) -> Result<(), Self::Error> {
-        let missing_shards = self.resolve_local_substates(transaction, out)?;
+    async fn resolve(&self, transaction: &Transaction) -> Result<IndexMap<SubstateId, Substate>, Self::Error> {
+        let mut substates = IndexMap::new();
+
+        let missing_shards = self.resolve_local_substates(transaction, &mut substates)?;
 
         // TODO: If any of the missing shards are local we should error early here rather than asking the local
         //       committee
 
-        self.resolve_remote_substates(missing_shards, out).await?;
+        self.resolve_remote_substates(missing_shards, &mut substates).await?;
 
-        Ok(())
+        Ok(substates)
     }
 
     async fn resolve_virtual_substates(
@@ -256,4 +257,6 @@ pub enum SubstateResolverError {
     EpochManagerError(#[from] EpochManagerError),
     #[error("Unauthorized fee claim: validator node {validator_address} (transaction signed by: {signer})")]
     UnauthorizedFeeClaim { validator_address: String, signer: String },
+    #[error("State store error: {0}")]
+    StateStorageError(#[from] StateStoreError),
 }
diff --git a/applications/tari_validator_node_cli/src/command/account.rs b/applications/tari_validator_node_cli/src/command/account.rs
index 68ac27e8f..f5ad33ad5 100644
--- a/applications/tari_validator_node_cli/src/command/account.rs
+++ b/applications/tari_validator_node_cli/src/command/account.rs
@@ -77,7 +77,6 @@ pub async fn handle_create(
         wait_for_result: true,
         wait_for_result_timeout: Some(60),
         inputs: vec![],
-        input_refs: vec![],
         version: None,
         dump_outputs_into: None,
         account_template_address: None,
diff --git a/applications/tari_validator_node_cli/src/command/transaction.rs b/applications/tari_validator_node_cli/src/command/transaction.rs
index b0a1c3ad0..ac99a9838 100644
--- a/applications/tari_validator_node_cli/src/command/transaction.rs
+++ b/applications/tari_validator_node_cli/src/command/transaction.rs
@@ -90,8 +90,6 @@ pub struct CommonSubmitArgs {
     pub wait_for_result_timeout: Option<u64>,
     #[clap(long, short = 'i')]
     pub inputs: Vec<SubstateRequirement>,
-    #[clap(long, alias = "ref")]
-    pub input_refs: Vec<SubstateRequirement>,
     #[clap(long, short = 'v')]
     pub version: Option<u8>,
     #[clap(long, short = 'd')]
@@ -231,15 +229,12 @@ pub async fn submit_transaction(
     // Convert to shard id
     let inputs = inputs.into_iter().collect::<Vec<_>>();
 
-    let input_refs = common.input_refs.into_iter().collect::<Vec<_>>();
-
     summarize_request(&instructions, &inputs, 1, common.dry_run);
     println!();
 
     let transaction = Transaction::builder()
         .with_instructions(instructions)
         .with_inputs(inputs)
-        .with_input_refs(input_refs)
         .sign(&key.secret_key)
         .build();
 
diff --git a/applications/tari_validator_node_web_ui/src/Components/StatusChip.tsx b/applications/tari_validator_node_web_ui/src/Components/StatusChip.tsx
index e1ddd637d..a15bf5367 100644
--- a/applications/tari_validator_node_web_ui/src/Components/StatusChip.tsx
+++ b/applications/tari_validator_node_web_ui/src/Components/StatusChip.tsx
@@ -22,9 +22,10 @@
 
 import { Chip, Avatar } from "@mui/material";
 import { IoCheckmarkOutline, IoHourglassOutline, IoCloseOutline, IoBandageOutline } from "react-icons/io5";
+import { Decision } from "@tariproject/typescript-bindings";
 
 interface StatusChipProps {
-  status: "Commit" | "Abort" | "Loading" | "Dummy";
+  status: Decision | "Loading" | "Dummy";
   showTitle?: boolean;
 }
 
diff --git a/bindings/index.ts b/bindings/index.ts
index b4e00b788..4dc1c1050 100644
--- a/bindings/index.ts
+++ b/bindings/index.ts
@@ -86,6 +86,7 @@ export * from "./src/types/SubstateAddress";
 export * from "./src/types/SubstateDestroyed";
 export * from "./src/types/SubstateDiff";
 export * from "./src/types/SubstateId";
+export * from "./src/types/SubstateLockFlag";
 export * from "./src/types/SubstateRecord";
 export * from "./src/types/SubstateRequirement";
 export * from "./src/types/Substate";
@@ -108,6 +109,7 @@ export * from "./src/types/UnsignedTransaction";
 export * from "./src/types/ValidatorSignature";
 export * from "./src/types/VaultId";
 export * from "./src/types/Vault";
+export * from "./src/types/VersionedSubstateIdLockIntent";
 export * from "./src/types/VersionedSubstateId";
 export * from "./src/types/ViewableBalanceProof";
 export * from "./src/helpers/helpers";
diff --git a/bindings/src/types/Decision.ts b/bindings/src/types/Decision.ts
index a697b0f15..1411b5cfe 100644
--- a/bindings/src/types/Decision.ts
+++ b/bindings/src/types/Decision.ts
@@ -1,3 +1,3 @@
 // This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
 
-export type Decision = "Commit" | "Abort";
+export type Decision = "Commit" | "Abort" | "Deferred";
diff --git a/bindings/src/types/ExecutedTransaction.ts b/bindings/src/types/ExecutedTransaction.ts
index 2b8c39c5e..1a50878a4 100644
--- a/bindings/src/types/ExecutedTransaction.ts
+++ b/bindings/src/types/ExecutedTransaction.ts
@@ -3,11 +3,13 @@ import type { Decision } from "./Decision";
 import type { ExecuteResult } from "./ExecuteResult";
 import type { Transaction } from "./Transaction";
 import type { VersionedSubstateId } from "./VersionedSubstateId";
+import type { VersionedSubstateIdLockIntent } from "./VersionedSubstateIdLockIntent";
 
 export interface ExecutedTransaction {
   transaction: Transaction;
   result: ExecuteResult;
   resulting_outputs: Array<VersionedSubstateId>;
+  resolved_inputs: Array<VersionedSubstateIdLockIntent> | null;
   execution_time: { secs: number; nanos: number };
   final_decision: Decision | null;
   finalized_time: { secs: number; nanos: number } | null;
diff --git a/bindings/src/types/SubstateLockFlag.ts b/bindings/src/types/SubstateLockFlag.ts
new file mode 100644
index 000000000..5f2a572eb
--- /dev/null
+++ b/bindings/src/types/SubstateLockFlag.ts
@@ -0,0 +1,3 @@
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+
+export type SubstateLockFlag = "Read" | "Write";
diff --git a/bindings/src/types/Transaction.ts b/bindings/src/types/Transaction.ts
index 77506f376..b893270ed 100644
--- a/bindings/src/types/Transaction.ts
+++ b/bindings/src/types/Transaction.ts
@@ -3,6 +3,7 @@ import type { Epoch } from "./Epoch";
 import type { Instruction } from "./Instruction";
 import type { SubstateRequirement } from "./SubstateRequirement";
 import type { TransactionSignature } from "./TransactionSignature";
+import type { VersionedSubstateId } from "./VersionedSubstateId";
 
 export interface Transaction {
   id: string;
@@ -10,8 +11,7 @@ export interface Transaction {
   instructions: Array<Instruction>;
   signature: TransactionSignature;
   inputs: Array<SubstateRequirement>;
-  input_refs: Array<SubstateRequirement>;
-  filled_inputs: Array<SubstateRequirement>;
+  filled_inputs: Array<VersionedSubstateId>;
   min_epoch: Epoch | null;
   max_epoch: Epoch | null;
 }
diff --git a/bindings/src/types/UnsignedTransaction.ts b/bindings/src/types/UnsignedTransaction.ts
index cb5677f98..8fe7927ca 100644
--- a/bindings/src/types/UnsignedTransaction.ts
+++ b/bindings/src/types/UnsignedTransaction.ts
@@ -2,13 +2,13 @@
 import type { Epoch } from "./Epoch";
 import type { Instruction } from "./Instruction";
 import type { SubstateRequirement } from "./SubstateRequirement";
+import type { VersionedSubstateId } from "./VersionedSubstateId";
 
 export interface UnsignedTransaction {
   fee_instructions: Array<Instruction>;
   instructions: Array<Instruction>;
   inputs: Array<SubstateRequirement>;
-  input_refs: Array<SubstateRequirement>;
-  filled_inputs: Array<SubstateRequirement>;
+  filled_inputs: Array<VersionedSubstateId>;
   min_epoch: Epoch | null;
   max_epoch: Epoch | null;
 }
diff --git a/bindings/src/types/VersionedSubstateIdLockIntent.ts b/bindings/src/types/VersionedSubstateIdLockIntent.ts
new file mode 100644
index 000000000..d40fb4228
--- /dev/null
+++ b/bindings/src/types/VersionedSubstateIdLockIntent.ts
@@ -0,0 +1,8 @@
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+import type { SubstateLockFlag } from "./SubstateLockFlag";
+import type { VersionedSubstateId } from "./VersionedSubstateId";
+
+export interface VersionedSubstateIdLockIntent {
+  versioned_substate_id: VersionedSubstateId;
+  lock_flag: SubstateLockFlag;
+}
diff --git a/clients/wallet_daemon_client/src/types.rs b/clients/wallet_daemon_client/src/types.rs
index 63b384850..add008ae2 100644
--- a/clients/wallet_daemon_client/src/types.rs
+++ b/clients/wallet_daemon_client/src/types.rs
@@ -720,6 +720,7 @@ pub struct ConfidentialViewVaultBalanceResponse {
 pub struct ClaimBurnRequest {
     #[serde(deserialize_with = "opt_string_or_struct")]
     pub account: Option<ComponentAddressOrName>,
+    // TODO: make this a type
     #[cfg_attr(feature = "ts", ts(type = "string"))]
     pub claim_proof: serde_json::Value,
     pub max_fee: Option<Amount>,
diff --git a/dan_layer/common_types/src/validator_metadata.rs b/dan_layer/common_types/src/validator_metadata.rs
index d7549189f..1ef8d1392 100644
--- a/dan_layer/common_types/src/validator_metadata.rs
+++ b/dan_layer/common_types/src/validator_metadata.rs
@@ -27,13 +27,9 @@ impl ValidatorMetadata {
 }
 
 pub fn vn_node_hash(network: Network, public_key: &PublicKey, substate_address: &SubstateAddress) -> FixedHash {
-    // TODO: TariBaseLayerHasher32 is the same as the consensus hasher in tari_core. The consensus hasher should be part
-    // of the common hashing crate, currently called tari_hashing. Should rename it to tari_hasher/tari_hashing
-    // and include the consensus hasher. This is done to remove the dependency on tari_core which has a bunch of
-    // dependencies e.g. tari_comms, dht etc. "Type" crates should always have minimal dependencies.
-    TariBaseLayerHasher32::new_with_label::<TransactionHashDomain>(network, "validator_node")
+    TariBaseLayerHasher32::<TransactionHashDomain>::new_with_label(&format!("validator_nodes.n{}", network.as_byte()))
         .chain(public_key)
         .chain(&substate_address.0)
-        .result()
+        .finalize()
         .into()
 }
diff --git a/dan_layer/consensus/src/hotstuff/error.rs b/dan_layer/consensus/src/hotstuff/error.rs
index 731dd281e..71a1362e3 100644
--- a/dan_layer/consensus/src/hotstuff/error.rs
+++ b/dan_layer/consensus/src/hotstuff/error.rs
@@ -10,7 +10,7 @@ use tari_dan_storage::{
 use tari_epoch_manager::EpochManagerError;
 use tari_mmr::BalancedBinaryMerkleProofError;
 use tari_state_tree::StateTreeError;
-use tari_transaction::TransactionId;
+use tari_transaction::{TransactionId, VersionedSubstateIdError};
 
 use crate::traits::{InboundMessagingError, OutboundMessagingError};
 
@@ -88,6 +88,8 @@ pub enum HotStuffError {
     TransactionExecutorError(String),
     #[error("Invalid sync request: {details}")]
     InvalidSyncRequest { details: String },
+    #[error("Some input versions were not resolved at execution time: {0}")]
+    VersionedSubstateIdError(#[from] VersionedSubstateIdError),
 }
 
 impl From<EpochManagerError> for HotStuffError {
diff --git a/dan_layer/consensus/src/hotstuff/on_inbound_message.rs b/dan_layer/consensus/src/hotstuff/on_inbound_message.rs
index d164cdf0b..b8204943a 100644
--- a/dan_layer/consensus/src/hotstuff/on_inbound_message.rs
+++ b/dan_layer/consensus/src/hotstuff/on_inbound_message.rs
@@ -178,7 +178,7 @@ where TConsensusSpec: ConsensusSpec
             .with_write_tx(|tx| tx.missing_transactions_remove(current_height, transaction_id))?;
 
         if let Some(unparked_block) = maybe_unparked_block {
-            info!(target: LOG_TARGET, "♻️ all transactions for block {unparked_block} have been executed");
+            info!(target: LOG_TARGET, "♻️ all transactions for block {unparked_block} are ready for consensus");
 
             let vn = self
                 .epoch_manager
@@ -212,16 +212,16 @@ where TConsensusSpec: ConsensusSpec
                 "🔥 Block {} has {} missing transactions and {} awaiting execution", block, missing_tx_ids.len(), awaiting_execution.len(),
             );
 
-            let block_id = *block.id();
-            let epoch = block.epoch();
-            let block_proposed_by = block.proposed_by().clone();
+            if !missing_tx_ids.is_empty() {
+                let block_id = *block.id();
+                let epoch = block.epoch();
+                let block_proposed_by = block.proposed_by().clone();
 
-            let vn = self
-                .epoch_manager
-                .get_validator_node_by_public_key(epoch, &block_proposed_by)
-                .await?;
+                let vn = self
+                    .epoch_manager
+                    .get_validator_node_by_public_key(epoch, &block_proposed_by)
+                    .await?;
 
-            if !missing_tx_ids.is_empty() {
                 self.outbound_messaging
                     .send(
                         vn.address,
diff --git a/dan_layer/consensus/src/hotstuff/on_propose.rs b/dan_layer/consensus/src/hotstuff/on_propose.rs
index 018f0ae58..ee6056112 100644
--- a/dan_layer/consensus/src/hotstuff/on_propose.rs
+++ b/dan_layer/consensus/src/hotstuff/on_propose.rs
@@ -109,7 +109,7 @@ where TConsensusSpec: ConsensusSpec
                             next_block.justify().block_height(),
                             next_block.parent(),
                         );
-                        self.broadcast_proposal_locally(next_block, local_committee).await?;
+                        self.broadcast_local_proposal(next_block, local_committee).await?;
                         return Ok(());
                     }
                 }
@@ -194,7 +194,7 @@ where TConsensusSpec: ConsensusSpec
 
         info!(
             target: LOG_TARGET,
-            "🌿 PROPOSING locally new block {} to {} validators. justify: {} ({}), parent: {}",
+            "🌿 PROPOSING new local block {} to {} validators. justify: {} ({}), parent: {}",
             next_block,
             local_committee.len(),
             next_block.justify().block_id(),
@@ -202,19 +202,19 @@ where TConsensusSpec: ConsensusSpec
             next_block.parent()
         );
 
-        self.broadcast_proposal_locally(next_block, local_committee).await?;
+        self.broadcast_local_proposal(next_block, local_committee).await?;
 
         Ok(())
     }
 
-    pub async fn broadcast_proposal_locally(
+    pub async fn broadcast_local_proposal(
         &mut self,
         next_block: Block,
         local_committee: &Committee<TConsensusSpec::Addr>,
     ) -> Result<(), HotStuffError> {
         info!(
             target: LOG_TARGET,
-            "🌿 Broadcasting locally proposal {} to {} local committees",
+            "🌿 Broadcasting local proposal {} to {} local committees",
             next_block,
             local_committee.len(),
         );
@@ -269,12 +269,13 @@ where TConsensusSpec: ConsensusSpec
             ForeignProposal::get_all_new(tx)?
                 .into_iter()
                 .filter(|foreign_proposal| {
+                    // If the proposal base layer height is too high, ignore for now.
+                    foreign_proposal.base_layer_block_height <= base_layer_block_height &&
                     // If the foreign proposal is already pending, don't propose it again
                     !pending_proposals.iter().any(|pending_proposal| {
                         pending_proposal.bucket == foreign_proposal.bucket &&
                             pending_proposal.block_id == foreign_proposal.block_id
-                    })// If the proposal base layer height is too high, ignore for now.
-                    && foreign_proposal.base_layer_block_height <= base_layer_block_height
+                    })
                 })
                 .map(|mut foreign_proposal| {
                     foreign_proposal.set_proposed_height(parent_block.height().saturating_add(NodeHeight(1)));
@@ -355,7 +356,7 @@ fn transaction_pool_record_to_command<TTx: StateStoreReadTransaction>(
     local_committee_shard: &CommitteeShard,
     substate_changes: &mut Vec<SubstateChange>,
 ) -> Result<Command, HotStuffError> {
-    let involved = local_committee_shard.count_distinct_shards(t.transaction().evidence.shards_iter());
+    let involved = local_committee_shard.count_distinct_shards(t.transaction().evidence.substate_addresses_iter());
     if involved == 1 {
         info!(
             target: LOG_TARGET,
diff --git a/dan_layer/consensus/src/hotstuff/on_ready_to_vote_on_local_block.rs b/dan_layer/consensus/src/hotstuff/on_ready_to_vote_on_local_block.rs
index 366f5df7b..778a34ecf 100644
--- a/dan_layer/consensus/src/hotstuff/on_ready_to_vote_on_local_block.rs
+++ b/dan_layer/consensus/src/hotstuff/on_ready_to_vote_on_local_block.rs
@@ -32,12 +32,13 @@ use tari_dan_storage::{
         TransactionAtom,
         TransactionPool,
         TransactionPoolStage,
+        TransactionRecord,
         ValidBlock,
     },
     StateStore,
 };
 use tari_epoch_manager::EpochManagerReader;
-use tari_transaction::{Transaction, TransactionId, VersionedSubstateId};
+use tari_transaction::{TransactionId, VersionedSubstateId};
 use tokio::sync::broadcast;
 
 use super::proposer::Proposer;
@@ -123,24 +124,23 @@ where TConsensusSpec: ConsensusSpec
             .await?;
         let mut locked_blocks = Vec::new();
         let mut finalized_transactions = Vec::new();
-        let qc_block = self
-            .store
-            .with_read_tx(|tx| valid_block.block().justify().get_block(tx))?;
-        let locked_block = self.store.with_read_tx(|tx| LockedBlock::get(tx)?.get_block(tx))?;
-        // If the previous qc block was in different epoch, we have to have EpochEvent::Start
-        let epoch_should_start = qc_block.epoch() < valid_block.epoch();
-
-        let epoch_should_end =
-            // If the epoch has not changed yet
-            qc_block.epoch() == valid_block.epoch() &&
-            // If the last justified block is an epoch end
-            qc_block.is_epoch_end() &&
-            // if the locked block is an epoch end, then we do not expect this block to be an epoch end
-            !locked_block.is_epoch_end() &&
-            // If the previous epoch is the genesis epoch, we don't need to end it (there was no committee at epoch 0)
-            !qc_block.is_genesis();
-
         let maybe_decision = self.store.with_write_tx(|tx| {
+            let qc_block = valid_block.block().justify().get_block(tx.deref_mut())?;
+            let locked_block = LockedBlock::get(tx.deref_mut())?.get_block(tx.deref_mut())?;
+
+            // If the previous qc block was in different epoch, we have to have EpochEvent::Start
+            let epoch_should_start = qc_block.epoch() < valid_block.epoch();
+
+            let epoch_should_end =
+                // If the epoch has not changed yet
+                qc_block.epoch() == valid_block.epoch() &&
+                // If the last justified block is an epoch end
+                qc_block.is_epoch_end() &&
+                // if the locked block is an epoch end, then we do not expect this block to be an epoch end
+                !locked_block.is_epoch_end() &&
+                // If the previous epoch is the genesis epoch, we don't need to end it (there was no committee at epoch 0)
+                !qc_block.is_genesis();
+
             let mut maybe_decision = self.decide_on_block(
                 tx,
                 &local_committee_shard,
@@ -149,7 +149,7 @@ where TConsensusSpec: ConsensusSpec
                 epoch_should_end,
             )?;
 
-            let is_accept_decision = maybe_decision.map(|d| d.is_accept()).unwrap_or(false);
+            let is_accept_decision = maybe_decision.map_or(false, |d| d.is_accept());
             // Update nodes
             if is_accept_decision {
                 let high_qc = valid_block.block().update_nodes(
@@ -262,8 +262,7 @@ where TConsensusSpec: ConsensusSpec
                     if t.decision.is_commit() {
                         let transaction = ExecutedTransaction::get(tx.deref_mut(), &t.id)?;
                         // Lock all inputs for the transaction as part of Prepare
-                        let is_inputs_locked =
-                            self.lock_inputs(tx, transaction.transaction(), local_committee_shard)?;
+                        let is_inputs_locked = self.lock_inputs(tx, &transaction, local_committee_shard)?;
                         let is_outputs_locked = is_inputs_locked && self.lock_outputs(tx, leaf.id(), &transaction)?;
 
                         // This should not be possible and may be due to a BUG. The failure to lock the leaf block
@@ -288,7 +287,9 @@ where TConsensusSpec: ConsensusSpec
 
                             // The leader should not have proposed conflicting transactions
                             return Ok(false);
-                        } else if !is_outputs_locked {
+                        }
+
+                        if !is_outputs_locked {
                             // Unable to lock all outputs - do not vote
                             warn!(
                                 target: LOG_TARGET,
@@ -299,14 +300,12 @@ where TConsensusSpec: ConsensusSpec
                                 Decision::Abort
                             );
                             // Unlock any locked inputs because we are not voting
-                            self.unlock_inputs(tx, transaction.transaction(), local_committee_shard)?;
+                            self.unlock_inputs(tx, &transaction, local_committee_shard)?;
                             // We change our decision to ABORT so that the next time we propose/receive a
                             // proposal we will check for ABORT
                             let mut tx_rec = self.transaction_pool.get(tx, tip_block.as_leaf_block(), t.id())?;
                             tx_rec.update_local_decision(tx, Decision::Abort)?;
                             return Ok(false);
-                        } else {
-                            // We have locked all inputs and outputs
                         }
                     }
                 },
@@ -314,8 +313,7 @@ where TConsensusSpec: ConsensusSpec
                     if t.decision.is_commit() {
                         let transaction = ExecutedTransaction::get(tx.deref_mut(), &t.id)?;
                         // Lock all inputs for the transaction as part of Prepare
-                        let is_inputs_locked =
-                            self.lock_inputs(tx, transaction.transaction(), local_committee_shard)?;
+                        let is_inputs_locked = self.lock_inputs(tx, &transaction, local_committee_shard)?;
                         let is_outputs_locked = is_inputs_locked && self.lock_outputs(tx, leaf.id(), &transaction)?;
 
                         if !is_inputs_locked {
@@ -349,7 +347,7 @@ where TConsensusSpec: ConsensusSpec
                                 Decision::Abort
                             );
                             // Unlock any locked inputs because we are not voting
-                            self.unlock_inputs(tx, transaction.transaction(), local_committee_shard)?;
+                            self.unlock_inputs(tx, &transaction, local_committee_shard)?;
                             // We change our decision to ABORT so that the next time we propose/receive a
                             // proposal we will check for ABORT
                             let mut tx_rec = self.transaction_pool.get(tx, tip_block.as_leaf_block(), t.id())?;
@@ -525,13 +523,13 @@ where TConsensusSpec: ConsensusSpec
                 continue;
             }
 
-            let transaction = cmd
+            let atom = cmd
                 .transaction()
-                .expect("foreign proposal already checked, all remaining commands must have a transaction atom");
+                .expect("all remaining commands have a transaction atom");
 
             let Some(mut tx_rec) = self
                 .transaction_pool
-                .get(tx, block.as_leaf_block(), transaction.id())
+                .get(tx, block.as_leaf_block(), atom.id())
                 .optional()?
             else {
                 warn!(
@@ -543,6 +541,19 @@ where TConsensusSpec: ConsensusSpec
                 return Ok(None);
             };
 
+            if tx_rec.is_deferred() {
+                info!(
+                    target: LOG_TARGET,
+                    "👨‍🔧 Executing deferred transaction {} in block {}",
+                    tx_rec.transaction_id(),
+                    block,
+                );
+
+                let executed = self.execute_transaction(tx, &atom.id, &mut executor)?;
+                self.transaction_pool.set_atom(tx, executed.to_atom())?;
+                tx_rec = self.transaction_pool.get(tx, block.as_leaf_block(), executed.id())?;
+            }
+
             // TODO: we probably need to provide the all/some of the QCs referenced in local transactions as
             //       part of the proposal DanMessage so that there is no race condition between receiving the
             //       proposed block and receiving the foreign proposals. Because this is only added on locked block,
@@ -557,7 +568,7 @@ where TConsensusSpec: ConsensusSpec
             );
             match cmd {
                 Command::LocalOnly(t) => {
-                    if !tx_rec.current_stage().is_new() && !tx_rec.current_stage().is_local_only() {
+                    if !tx_rec.current_stage().is_new() {
                         warn!(
                             target: LOG_TARGET,
                             "❌ Stage disagreement for tx {} in block {}. Leader proposed LocalOnly, local stage is {}",
@@ -581,8 +592,9 @@ where TConsensusSpec: ConsensusSpec
 
                     if tx_rec.current_decision() == t.decision {
                         if tx_rec.current_decision().is_commit() {
-                            let executed = self.get_executed_transaction(tx, &t.id, &mut executor)?;
-                            if !local_committee_shard.includes_all_substate_addresses(executed.involved_shards_iter()) {
+                            if !local_committee_shard.includes_all_substate_addresses(
+                                tx_rec.transaction().evidence.substate_addresses_iter(),
+                            ) {
                                 warn!(
                                     target: LOG_TARGET,
                                     "❌ LocalOnly transaction {} in block {} has more than one involved shard",
@@ -592,11 +604,10 @@ where TConsensusSpec: ConsensusSpec
                                 return Ok(None);
                             }
 
-                            let transaction = executed.transaction();
-
+                            let executed = ExecutedTransaction::get(tx.deref_mut(), &t.id)?;
                             // Lock all inputs for the transaction as part of LocalOnly
                             let is_inputs_locked =
-                                self.check_lock_inputs(tx, transaction, local_committee_shard, &mut locked_inputs)?;
+                                self.check_lock_inputs(tx, &executed, local_committee_shard, &mut locked_inputs)?;
                             let is_outputs_locked = is_inputs_locked &&
                                 self.check_lock_outputs(tx, &executed, &mut locked_outputs, &locked_inputs)?;
 
@@ -606,7 +617,7 @@ where TConsensusSpec: ConsensusSpec
                                     target: LOG_TARGET,
                                     "❌ Unable to lock all inputs for transaction {} in block {}.",
                                     block,
-                                    transaction.id(),
+                                    executed.id(),
                                 );
                                 // We change our decision to ABORT so that the next time we propose/receive a
                                 // proposal we will check for ABORT. It may
@@ -623,7 +634,7 @@ where TConsensusSpec: ConsensusSpec
                                     target: LOG_TARGET,
                                     "❌ Unable to lock all outputs for transaction {} in block {}.",
                                     block,
-                                    transaction.id(),
+                                    executed.id(),
                                 );
                                 // We change our decision to ABORT so that the next time we propose/receive a
                                 // proposal we will check for ABORT
@@ -631,13 +642,6 @@ where TConsensusSpec: ConsensusSpec
                                 return Ok(None);
                             } else {
                                 // We have locked all inputs and outputs
-
-                                // We need to update the database (transaction result and inputs/outputs)
-                                // in case the transaction was re-executed because it has inputs without versions
-                                let has_involved_shards = executed.num_involved_shards() > 0;
-                                if transaction.has_inputs_without_version() && has_involved_shards {
-                                    executed.update(tx)?;
-                                }
                             }
 
                             if t.leader_fee.is_none() {
@@ -710,12 +714,11 @@ where TConsensusSpec: ConsensusSpec
 
                     if tx_rec.current_decision() == t.decision {
                         if tx_rec.current_decision().is_commit() {
-                            let executed = self.get_executed_transaction(tx, &t.id, &mut executor)?;
-                            let transaction = executed.transaction();
+                            let executed = ExecutedTransaction::get(tx.deref_mut(), &t.id)?;
 
                             // Lock all inputs for the transaction as part of Prepare
                             let is_inputs_locked =
-                                self.check_lock_inputs(tx, transaction, local_committee_shard, &mut locked_inputs)?;
+                                self.check_lock_inputs(tx, &executed, local_committee_shard, &mut locked_inputs)?;
                             let is_outputs_locked = is_inputs_locked &&
                                 self.check_lock_outputs(tx, &executed, &mut locked_outputs, &locked_inputs)?;
 
@@ -725,7 +728,7 @@ where TConsensusSpec: ConsensusSpec
                                     target: LOG_TARGET,
                                     "❌ Unable to lock all inputs for transaction {} in block {}.",
                                     block,
-                                    transaction.id(),
+                                    executed.id(),
                                 );
                                 // We change our decision to ABORT so that the next time we propose/receive a
                                 // proposal we will check for ABORT. It may
@@ -742,7 +745,7 @@ where TConsensusSpec: ConsensusSpec
                                     target: LOG_TARGET,
                                     "❌ Unable to lock all outputs for transaction {} in block {}.",
                                     block,
-                                    transaction.id(),
+                                    executed.id(),
                                 );
                                 // We change our decision to ABORT so that the next time we propose/receive a
                                 // proposal we will check for ABORT
@@ -750,13 +753,6 @@ where TConsensusSpec: ConsensusSpec
                                 return Ok(None);
                             } else {
                                 // We have locked all inputs and outputs
-
-                                // We need to update the database (transaction result and inputs/outpus)
-                                // in case the transaction was re-executed because it has inputs without versions
-                                let has_involved_shards = executed.num_involved_shards() > 0;
-                                if transaction.has_inputs_without_version() && has_involved_shards {
-                                    executed.update(tx)?;
-                                }
                             }
                         }
 
@@ -894,8 +890,8 @@ where TConsensusSpec: ConsensusSpec
                         return Ok(None);
                     }
 
-                    let distinct_shards =
-                        local_committee_shard.count_distinct_shards(tx_rec.transaction().evidence.shards_iter());
+                    let distinct_shards = local_committee_shard
+                        .count_distinct_shards(tx_rec.transaction().evidence.substate_addresses_iter());
                     let distinct_shards = NonZeroU64::new(distinct_shards as u64).ok_or_else(|| {
                         HotStuffError::InvariantError(format!(
                             "Distinct shards is zero for transaction {} in block {}",
@@ -973,51 +969,54 @@ where TConsensusSpec: ConsensusSpec
         Ok(Some(QuorumDecision::Accept))
     }
 
-    // Returns the execution result of a transaction.
-    // If the transaction has all inputs with specific versions, it was executed in the mempool so we only fetch the
-    // result from database. If the transaction has one or more inputs without version, we execute it now with the
-    // most recent input versions it needs.
-    fn get_executed_transaction(
+    // Executes the given transaction.
+    // If the transaction has already been executed it will be re-executed.
+    fn execute_transaction(
         &self,
         tx: &mut <TConsensusSpec::StateStore as StateStore>::WriteTransaction<'_>,
         transaction_id: &TransactionId,
-        executor: &mut Box<dyn BlockTransactionExecutor<TConsensusSpec::StateStore>>,
+        executor: &mut <TConsensusSpec::BlockTransactionExecutorBuilder as BlockTransactionExecutorBuilder<
+            TConsensusSpec::StateStore,
+        >>::Executor,
     ) -> Result<ExecutedTransaction, HotStuffError> {
-        let executed = ExecutedTransaction::get(tx.deref_mut(), transaction_id)?;
-        let transaction = executed.transaction();
-
-        // TODO: currently, we can have transactions that involve no shards (CreateFreeTestCoin). So we need to execute
-        // in this case too.
-        if transaction.has_inputs_without_version() || transaction.num_involved_shards() == 0 {
-            let executed = executor
-                .execute(executed.transaction().clone(), tx)
-                .map_err(|e| HotStuffError::TransactionExecutorError(e.to_string()))?;
-            Ok(executed)
-        } else {
-            Ok(executed)
-        }
+        let transaction = TransactionRecord::get(tx.deref_mut(), transaction_id)?;
+
+        info!(
+            target: LOG_TARGET,
+            "🔥 Executing transaction {}",
+            transaction_id,
+        );
+
+        let executed = executor
+            .execute(transaction.into_transaction(), tx)
+            .map_err(|e| HotStuffError::TransactionExecutorError(e.to_string()))?;
+
+        executed.update(tx)?;
+        Ok(executed)
     }
 
     fn lock_inputs(
         &self,
         tx: &mut <TConsensusSpec::StateStore as StateStore>::WriteTransaction<'_>,
-        transaction: &Transaction,
+        transaction: &ExecutedTransaction,
         local_committee_shard: &CommitteeShard,
     ) -> Result<bool, HotStuffError> {
-        // For now we are going to only lock inputs with specific versions
-        // TODO: for inputs without version, investigate if we need to use the results of re-execution
-        let inputs: Vec<SubstateAddress> = transaction
-            .inputs()
-            .iter()
-            .chain(transaction.filled_inputs())
-            .filter(|i| i.version().is_some())
-            .map(|i| i.to_substate_address())
-            .collect::<Vec<_>>();
+        let resolved_inputs = transaction.resolved_inputs().ok_or_else(|| {
+            HotStuffError::InvariantError(format!(
+                "Attempt to lock inputs on transaction {} but inputs are not resolved",
+                transaction.transaction().id()
+            ))
+        })?;
 
         let state = SubstateRecord::try_lock_all(
             tx,
             transaction.id(),
-            local_committee_shard.filter(inputs.iter()),
+            local_committee_shard.filter(
+                resolved_inputs
+                    .iter()
+                    .filter(|i| i.lock_flag().is_write())
+                    .map(|i| i.to_substate_address()),
+            ),
             SubstateLockFlag::Write,
         )?;
         if !state.is_acquired() {
@@ -1030,18 +1029,15 @@ where TConsensusSpec: ConsensusSpec
             return Ok(false);
         }
 
-        // TODO: Same as before, for inputs without version, investigate if we need to use the results of re-execution
-        let inputs: Vec<SubstateAddress> = transaction
-            .input_refs()
-            .iter()
-            .filter(|i| i.version().is_some())
-            .map(|i| i.to_substate_address())
-            .collect();
-
         let state = SubstateRecord::try_lock_all(
             tx,
             transaction.id(),
-            local_committee_shard.filter(inputs.iter()),
+            local_committee_shard.filter(
+                resolved_inputs
+                    .iter()
+                    .filter(|i| i.lock_flag().is_read())
+                    .map(|i| i.to_substate_address()),
+            ),
             SubstateLockFlag::Read,
         )?;
 
@@ -1067,65 +1063,75 @@ where TConsensusSpec: ConsensusSpec
     fn check_lock_inputs(
         &self,
         tx: &mut <TConsensusSpec::StateStore as StateStore>::ReadTransaction<'_>,
-        transaction: &Transaction,
+        transaction: &ExecutedTransaction,
         local_committee_shard: &CommitteeShard,
         locked_inputs: &mut HashSet<SubstateAddress>,
     ) -> Result<bool, HotStuffError> {
-        // TODO: for inputs without version, investigate if we need to use the results of re-execution
-        let inputs = local_committee_shard
-            .filter(
-                transaction
-                    .inputs()
-                    .iter()
-                    .chain(transaction.filled_inputs())
-                    .filter(|i| i.version().is_some())
-                    .map(|i| i.to_substate_address()),
-            )
-            .collect::<HashSet<_>>();
-        let state = SubstateRecord::check_lock_all(tx, inputs.iter(), SubstateLockFlag::Write)?;
-        if !state.is_acquired() {
+        let resolved_inputs = transaction.resolved_inputs().ok_or_else(|| {
+            HotStuffError::InvariantError(format!(
+                "Attempt to lock inputs on transaction {} but inputs are not resolved",
+                transaction.transaction().id()
+            ))
+        })?;
+
+        // TODO: this doesnt check read/write semantics
+        if resolved_inputs
+            .iter()
+            .any(|addr| locked_inputs.contains(&addr.to_substate_address()))
+        {
             warn!(
                 target: LOG_TARGET,
-                "❌ Unable to write lock all inputs for transaction {}: {:?}",
+                "❌ Locks for transaction {} conflict with other transactions in the block",
                 transaction.id(),
-                state,
             );
             return Ok(false);
         }
-        if inputs.iter().any(|i| locked_inputs.contains(i)) {
+
+        let state = SubstateRecord::check_lock_all(
+            tx,
+            local_committee_shard.filter(
+                resolved_inputs
+                    .iter()
+                    .filter(|i| i.lock_flag().is_write())
+                    .map(|i| i.to_substate_address()),
+            ),
+            SubstateLockFlag::Write,
+        )?;
+        if !state.is_acquired() {
             warn!(
                 target: LOG_TARGET,
-                "❌ Locks for transaction {} conflict with other transactions in the block",
+                "❌ Unable to write lock all inputs for transaction {}: {:?}",
                 transaction.id(),
+                state,
             );
             return Ok(false);
         }
-        locked_inputs.extend(inputs);
-        // TODO: Same as before, for inputs without version, investigate if we need to use the results of re-execution
-        let inputs = local_committee_shard
-            .filter(
-                transaction
-                    .input_refs()
+
+        let state = SubstateRecord::check_lock_all(
+            tx,
+            local_committee_shard.filter(
+                resolved_inputs
                     .iter()
-                    .filter(|i| i.version().is_some())
+                    .filter(|i| i.lock_flag().is_read())
                     .map(|i| i.to_substate_address()),
-            )
-            .collect::<HashSet<_>>();
-        let state = SubstateRecord::check_lock_all(tx, inputs.iter(), SubstateLockFlag::Read)?;
-
+            ),
+            SubstateLockFlag::Read,
+        )?;
         if !state.is_acquired() {
             warn!(
                 target: LOG_TARGET,
-                "❌ Unable to read lock all input refs for transaction {}: {:?}",
+                "❌ Unable to read lock all inputs for transaction {}: {:?}",
                 transaction.id(),
                 state,
             );
             return Ok(false);
         }
 
+        locked_inputs.extend(resolved_inputs.iter().map(|i| i.to_substate_address()));
+
         debug!(
             target: LOG_TARGET,
-            "🔒️ Locked inputs for transaction {}",
+            "🔒️ Input locks check OK for transaction {}",
             transaction.id(),
         );
 
@@ -1135,36 +1141,40 @@ where TConsensusSpec: ConsensusSpec
     fn unlock_inputs(
         &self,
         tx: &mut <TConsensusSpec::StateStore as StateStore>::WriteTransaction<'_>,
-        transaction: &Transaction,
+        transaction: &ExecutedTransaction,
         local_committee_shard: &CommitteeShard,
     ) -> Result<(), HotStuffError> {
-        // We ignore inputs without version
-        let write_inputs: Vec<SubstateAddress> = transaction
-            .inputs()
-            .iter()
-            .chain(transaction.filled_inputs())
-            .filter(|i| i.version().is_some())
-            .map(|i| i.to_substate_address())
-            .collect();
+        let inputs = transaction.resolved_inputs().ok_or_else(|| {
+            HotStuffError::InvariantError(format!(
+                "Attempt to unlock inputs on transaction {} but inputs are not resolved",
+                transaction.transaction().id()
+            ))
+        })?;
+
         SubstateRecord::try_unlock_many(
             tx,
             transaction.id(),
-            local_committee_shard.filter(write_inputs.iter()),
+            local_committee_shard.filter(
+                inputs
+                    .iter()
+                    .filter(|i| i.lock_flag().is_write())
+                    .map(|i| i.to_substate_address()),
+            ),
             SubstateLockFlag::Write,
         )?;
-        // We ignore inputs without version
-        let read_inputs: Vec<SubstateAddress> = transaction
-            .input_refs()
-            .iter()
-            .filter(|i| i.version().is_some())
-            .map(|i| i.to_substate_address())
-            .collect();
+
         SubstateRecord::try_unlock_many(
             tx,
             transaction.id(),
-            local_committee_shard.filter(read_inputs.iter()),
+            local_committee_shard.filter(
+                inputs
+                    .iter()
+                    .filter(|i| i.lock_flag().is_read())
+                    .map(|i| i.to_substate_address()),
+            ),
             SubstateLockFlag::Read,
         )?;
+
         Ok(())
     }
 
@@ -1233,7 +1243,11 @@ where TConsensusSpec: ConsensusSpec
         }
 
         locked_outputs.extend(resulting_outputs.iter().cloned());
-
+        debug!(
+            target: LOG_TARGET,
+            "🔒️ Output locks check OK for transaction {}",
+            transaction.id(),
+        );
         Ok(true)
     }
 
@@ -1420,7 +1434,7 @@ where TConsensusSpec: ConsensusSpec
                     if tx_rec.current_decision().is_commit() {
                         // We unlock just so that inputs that were not mutated are unlocked, even though those
                         // should be in input_refs
-                        self.unlock_inputs(tx, executed.transaction(), local_committee_shard)?;
+                        self.unlock_inputs(tx, &executed, local_committee_shard)?;
                         // Unlock any outputs that were locked
                         self.unlock_outputs(tx, &executed, local_committee_shard)?;
                     }
diff --git a/dan_layer/consensus/src/hotstuff/on_receive_foreign_proposal.rs b/dan_layer/consensus/src/hotstuff/on_receive_foreign_proposal.rs
index 4a09fd519..26d326f7d 100644
--- a/dan_layer/consensus/src/hotstuff/on_receive_foreign_proposal.rs
+++ b/dan_layer/consensus/src/hotstuff/on_receive_foreign_proposal.rs
@@ -97,7 +97,7 @@ where TConsensusSpec: ConsensusSpec
             .iter()
             .filter_map(|command| {
                 if let Some(tx) = command.local_prepared() {
-                    if !committee_shard.includes_any_shard(command.evidence().shards_iter()) {
+                    if !committee_shard.includes_any_shard(command.evidence().substate_addresses_iter()) {
                         return None;
                     }
                     // We are interested in the commands that are for us, they will be in local prepared and one of the
diff --git a/dan_layer/consensus/src/hotstuff/on_receive_requested_transactions.rs b/dan_layer/consensus/src/hotstuff/on_receive_requested_transactions.rs
index dd7b7b803..f7a4c019d 100644
--- a/dan_layer/consensus/src/hotstuff/on_receive_requested_transactions.rs
+++ b/dan_layer/consensus/src/hotstuff/on_receive_requested_transactions.rs
@@ -29,7 +29,7 @@ where TConsensusSpec: ConsensusSpec
         from: TConsensusSpec::Addr,
         msg: RequestedTransactionMessage,
     ) -> Result<(), HotStuffError> {
-        info!(target: LOG_TARGET, "{:?} receiving {} requested transactions for block {}", from, msg.transactions.len(), msg.block_id);
+        info!(target: LOG_TARGET, "Receiving {} requested transactions for block {} from {:?}", msg.transactions.len(), msg.block_id, from, );
         // TODO: Check that we requested this
         for tx in msg.transactions {
             self.tx_mempool
diff --git a/dan_layer/consensus/src/hotstuff/worker.rs b/dan_layer/consensus/src/hotstuff/worker.rs
index 954b2564f..2b6b1ed03 100644
--- a/dan_layer/consensus/src/hotstuff/worker.rs
+++ b/dan_layer/consensus/src/hotstuff/worker.rs
@@ -11,7 +11,7 @@ use log::*;
 use tari_common::configuration::Network;
 use tari_dan_common_types::NodeHeight;
 use tari_dan_storage::{
-    consensus_models::{Block, HighQc, LastVoted, LeafBlock, LockedBlock, TransactionPool},
+    consensus_models::{Block, HighQc, LastVoted, LeafBlock, LockedBlock, TransactionPool, TransactionRecord},
     StateStore,
 };
 use tari_epoch_manager::{EpochManagerEvent, EpochManagerReader};
@@ -259,14 +259,9 @@ impl<TConsensusSpec: ConsensusSpec> HotstuffWorker<TConsensusSpec> {
                 },
 
                 Some((tx_id, pending)) = self.rx_new_transactions.recv() => {
-                    self.hooks.on_transaction_ready(&tx_id);
-                    if let Err(err) = self.on_inbound_message.update_parked_blocks(current_height, &tx_id).await {
+                    if let Err(err) = self.on_new_transaction(tx_id, pending, current_height).await {
                         self.hooks.on_error(&err);
-                        error!(target: LOG_TARGET, "Error checking parked blocks: {}", err);
-                    }
-                    // Only propose now if there are no pending transactions
-                    if pending == 0 {
-                        self.pacemaker.beat();
+                        error!(target: LOG_TARGET, "Error handling new transaction: {}", err);
                     }
                 },
 
@@ -313,6 +308,46 @@ impl<TConsensusSpec: ConsensusSpec> HotstuffWorker<TConsensusSpec> {
         Ok(())
     }
 
+    async fn on_new_transaction(
+        &mut self,
+        tx_id: TransactionId,
+        num_pending_txs: usize,
+        current_height: NodeHeight,
+    ) -> Result<(), HotStuffError> {
+        let exists = self.state_store.with_write_tx(|tx| {
+            if self.transaction_pool.exists(tx.deref_mut(), &tx_id)? {
+                return Ok(true);
+            }
+            let transaction = TransactionRecord::get(tx.deref_mut(), &tx_id)?;
+            self.transaction_pool.insert(tx, transaction.to_atom())?;
+            Ok::<_, HotStuffError>(false)
+        })?;
+
+        debug!(
+            target: LOG_TARGET,
+            "🔥 new transaction ready for consensus: {} ({} pending)",
+            tx_id,
+            num_pending_txs
+        );
+
+        self.hooks.on_transaction_ready(&tx_id);
+        if let Err(err) = self
+            .on_inbound_message
+            .update_parked_blocks(current_height, &tx_id)
+            .await
+        {
+            self.hooks.on_error(&err);
+            error!(target: LOG_TARGET, "Error checking parked blocks: {}", err);
+        }
+        // There are num_pending_txs transactions in the queue. If we have no pending transactions, we'll propose now if
+        // able.
+        if !exists && num_pending_txs == 0 {
+            self.pacemaker.beat();
+        }
+
+        Ok(())
+    }
+
     async fn handle_epoch_manager_event(&mut self, event: EpochManagerEvent) -> Result<(), HotStuffError> {
         match event {
             EpochManagerEvent::EpochChanged(epoch) => {
diff --git a/dan_layer/consensus/src/messages/message.rs b/dan_layer/consensus/src/messages/message.rs
index 1f13f067e..5d651edda 100644
--- a/dan_layer/consensus/src/messages/message.rs
+++ b/dan_layer/consensus/src/messages/message.rs
@@ -65,9 +65,21 @@ impl Display for HotstuffMessage {
             HotstuffMessage::ForeignProposal(msg) => write!(f, "ForeignProposal({})", msg.block.height()),
             HotstuffMessage::Vote(msg) => write!(f, "Vote({}, {}, {})", msg.block_height, msg.block_id, msg.decision),
             HotstuffMessage::RequestMissingTransactions(msg) => {
-                write!(f, "RequestMissingTransactions({})", msg.transactions.len())
+                write!(
+                    f,
+                    "RequestMissingTransactions({} transaction(s), block: {}, epoch: {})",
+                    msg.transactions.len(),
+                    msg.block_id,
+                    msg.epoch
+                )
             },
-            HotstuffMessage::RequestedTransaction(msg) => write!(f, "RequestedTransaction({})", msg.transactions.len()),
+            HotstuffMessage::RequestedTransaction(msg) => write!(
+                f,
+                "RequestedTransaction({} transaction(s), block: {}, epoch: {})",
+                msg.transactions.len(),
+                msg.block_id,
+                msg.epoch
+            ),
             HotstuffMessage::SyncRequest(msg) => write!(f, "SyncRequest({})", msg.high_qc),
             HotstuffMessage::SyncResponse(msg) => write!(f, "SyncResponse({} block(s))", msg.blocks.len()),
         }
diff --git a/dan_layer/consensus/src/traits/transaction_executor.rs b/dan_layer/consensus/src/traits/transaction_executor.rs
index 3e5a56f1b..99aec77c7 100644
--- a/dan_layer/consensus/src/traits/transaction_executor.rs
+++ b/dan_layer/consensus/src/traits/transaction_executor.rs
@@ -2,13 +2,13 @@
 //   SPDX-License-Identifier: BSD-3-Clause
 
 use tari_dan_storage::{consensus_models::ExecutedTransaction, StateStore, StorageError};
+use tari_engine_types::substate::SubstateId;
 use tari_transaction::Transaction;
 
-// TODO: more refined errors
 #[derive(thiserror::Error, Debug)]
 pub enum BlockTransactionExecutorError {
-    #[error("Placeholder error")]
-    PlaceHolderError,
+    #[error("Unable to resolve substate id: {substate_id}")]
+    UnableToResolveSubstateId { substate_id: SubstateId },
     #[error("Execution thread failure: {0}")]
     ExecutionThreadFailure(String),
     #[error(transparent)]
@@ -16,6 +16,8 @@ pub enum BlockTransactionExecutorError {
     // TODO: remove this variant when we have a remote substate implementation
     #[error("Remote substates are now allowed")]
     RemoteSubstatesNotAllowed,
+    #[error("State store error: {0}")]
+    StateStoreError(String),
 }
 
 pub trait BlockTransactionExecutor<TStateStore: StateStore> {
@@ -27,5 +29,6 @@ pub trait BlockTransactionExecutor<TStateStore: StateStore> {
 }
 
 pub trait BlockTransactionExecutorBuilder<TStateStore: StateStore> {
-    fn build(&self) -> Box<dyn BlockTransactionExecutor<TStateStore>>;
+    type Executor: BlockTransactionExecutor<TStateStore>;
+    fn build(&self) -> Self::Executor;
 }
diff --git a/dan_layer/consensus_tests/src/consensus.rs b/dan_layer/consensus_tests/src/consensus.rs
index ed3fed1d1..0b4c9c6ba 100644
--- a/dan_layer/consensus_tests/src/consensus.rs
+++ b/dan_layer/consensus_tests/src/consensus.rs
@@ -17,11 +17,12 @@ use tari_dan_storage::{
     StateStore,
     StateStoreReadTransaction,
 };
-use tari_transaction::Transaction;
+use tari_transaction::{SubstateRequirement, Transaction};
 
 use crate::support::{
     build_transaction,
     build_transaction_from,
+    build_transaction_with_inputs,
     change_decision,
     logging::setup_logger,
     Test,
@@ -263,8 +264,8 @@ async fn multi_shard_propose_blocks_with_new_transactions_until_all_committed()
     test.assert_clean_shutdown().await;
 }
 
-#[ignore = "FIXME: This test is very flaky"]
 #[tokio::test(flavor = "multi_thread", worker_threads = 4)]
+#[ignore = "FIXME: This test is very flaky"]
 async fn foreign_shard_decides_to_abort() {
     setup_logger();
     let mut test = Test::builder()
@@ -278,7 +279,7 @@ async fn foreign_shard_decides_to_abort() {
     test.network()
         .send_transaction(TestNetworkDestination::Bucket(0), tx1.clone())
         .await;
-    let tx2 = change_decision(tx1.clone(), Decision::Abort);
+    let tx2 = change_decision(tx1.clone().try_into().unwrap(), Decision::Abort);
     test.network()
         .send_transaction(TestNetworkDestination::Bucket(1), tx2.clone())
         .await;
@@ -480,3 +481,58 @@ async fn foreign_block_distribution() {
     assert_eq!(test.network().total_messages_filtered(), 18);
     test.assert_clean_shutdown().await;
 }
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
+#[ignore = "this test requires some mechanism/'pledging' round for resolving inputs for proposal which has not been \
+            implemented"]
+async fn deferred_execution() {
+    setup_logger();
+    let mut test = Test::builder().add_committee(0, vec!["1"]).start().await;
+    // First get transaction in the mempool
+    let inputs = test.create_substates_on_all_vns(1);
+    // Remove versions from inputs to allow deferred transactions
+    let inputs = inputs
+        .into_iter()
+        .map(|i| SubstateRequirement::new(i.substate_id, None));
+    let tx = build_transaction_with_inputs(Decision::Deferred, 1, inputs);
+    test.network().send_transaction(TestNetworkDestination::All, tx).await;
+
+    test.wait_until_new_pool_count(1).await;
+    test.start_epoch(Epoch(0)).await;
+
+    loop {
+        test.on_block_committed().await;
+
+        if test.is_transaction_pool_empty() {
+            break;
+        }
+        let leaf = test.get_validator(&TestAddress::new("1")).get_leaf_block();
+        if leaf.height >= NodeHeight(10) {
+            panic!("Not all transaction committed after {} blocks", leaf.height);
+        }
+    }
+
+    test.assert_all_validators_at_same_height().await;
+    test.assert_all_validators_committed();
+
+    // Assert all LocalOnly
+    test.get_validator(&TestAddress::new("1"))
+        .state_store
+        .with_read_tx(|tx| {
+            let mut block = Some(Block::get_tip(tx)?);
+            loop {
+                block = block.as_ref().unwrap().get_parent(tx).optional()?;
+                let Some(b) = block.as_ref() else {
+                    break;
+                };
+
+                for cmd in b.commands() {
+                    assert!(matches!(cmd, Command::LocalOnly(_)));
+                }
+            }
+            Ok::<_, HotStuffError>(())
+        })
+        .unwrap();
+
+    test.assert_clean_shutdown().await;
+}
diff --git a/dan_layer/consensus_tests/src/support/harness.rs b/dan_layer/consensus_tests/src/support/harness.rs
index a5fa14e98..24046642a 100644
--- a/dan_layer/consensus_tests/src/support/harness.rs
+++ b/dan_layer/consensus_tests/src/support/harness.rs
@@ -12,13 +12,19 @@ use tari_consensus::hotstuff::HotstuffEvent;
 use tari_crypto::keys::{PublicKey as _, SecretKey};
 use tari_dan_common_types::{committee::Committee, shard::Shard, Epoch, NodeHeight};
 use tari_dan_storage::{
-    consensus_models::{Block, BlockId, Decision, TransactionPoolStage, TransactionRecord},
+    consensus_models::{Block, BlockId, Decision, QcId, SubstateRecord, TransactionPoolStage, TransactionRecord},
     StateStore,
     StateStoreReadTransaction,
+    StorageError,
+};
+use tari_engine_types::{
+    component::{ComponentBody, ComponentHeader},
+    substate::{SubstateId, SubstateValue},
 };
 use tari_epoch_manager::EpochManagerReader;
 use tari_shutdown::{Shutdown, ShutdownSignal};
-use tari_transaction::TransactionId;
+use tari_template_lib::models::ComponentAddress;
+use tari_transaction::{TransactionId, VersionedSubstateId};
 use tokio::{sync::broadcast, task};
 
 use super::MessageFilter;
@@ -60,6 +66,58 @@ impl Test {
         self.network.send_transaction(TestNetworkDestination::All, tx).await;
     }
 
+    pub fn create_substates_on_all_vns(&self, num: usize) -> Vec<VersionedSubstateId> {
+        assert!(
+            num <= u8::MAX as usize,
+            "Creating more than 255 substates is not supported"
+        );
+
+        let substates = (0..num)
+            .map(|i| {
+                let id = SubstateId::Component(ComponentAddress::from_array([i as u8; 28]));
+                let value = SubstateValue::Component(ComponentHeader {
+                    template_address: Default::default(),
+                    module_name: "Test".to_string(),
+                    owner_key: None,
+                    owner_rule: Default::default(),
+                    access_rules: Default::default(),
+                    entity_id: id.as_component_address().unwrap().entity_id(),
+                    body: ComponentBody {
+                        state: tari_bor::Value::Null,
+                    },
+                });
+                SubstateRecord::new(
+                    id,
+                    0,
+                    value,
+                    Epoch(0),
+                    NodeHeight(0),
+                    BlockId::genesis(),
+                    TransactionId::default(),
+                    QcId::genesis(),
+                )
+            })
+            .collect::<Vec<_>>();
+
+        let ids = substates
+            .iter()
+            .map(|s| VersionedSubstateId::new(s.substate_id().clone(), s.version()))
+            .collect::<Vec<_>>();
+
+        self.validators.values().for_each(|v| {
+            v.state_store
+                .with_write_tx(|tx| {
+                    for substate in substates.clone() {
+                        substate.create(tx).unwrap();
+                    }
+                    Ok::<_, StorageError>(())
+                })
+                .unwrap();
+        });
+
+        ids
+    }
+
     pub fn validators(&self) -> hash_map::Values<'_, TestAddress, Validator> {
         self.validators.values()
     }
@@ -185,7 +243,10 @@ impl Test {
             if complete.len() == self.validators.len() {
                 break;
             }
-            tokio::time::sleep(std::time::Duration::from_millis(100)).await;
+            if self.network.task_handle().is_finished() {
+                panic!("Network task exited while waiting for {}", description);
+            }
+            tokio::time::sleep(Duration::from_millis(100)).await;
         }
     }
 
diff --git a/dan_layer/consensus_tests/src/support/network.rs b/dan_layer/consensus_tests/src/support/network.rs
index 186dd039d..722384f80 100644
--- a/dan_layer/consensus_tests/src/support/network.rs
+++ b/dan_layer/consensus_tests/src/support/network.rs
@@ -11,16 +11,19 @@ use itertools::Itertools;
 use tari_consensus::messages::HotstuffMessage;
 use tari_dan_common_types::shard::Shard;
 use tari_dan_storage::{
-    consensus_models::{ExecutedTransaction, TransactionPool},
+    consensus_models::{TransactionPool, TransactionRecord},
     StateStore,
 };
 use tari_shutdown::ShutdownSignal;
 use tari_state_store_sqlite::SqliteStateStore;
 use tari_transaction::{Transaction, TransactionId};
-use tokio::sync::{
-    mpsc::{self},
-    watch,
-    RwLock,
+use tokio::{
+    sync::{
+        mpsc::{self},
+        watch,
+        RwLock,
+    },
+    task,
 };
 
 use crate::support::{address::TestAddress, ValidatorChannels};
@@ -63,7 +66,7 @@ pub fn spawn_network(
 
     let offline_destinations = Arc::new(RwLock::new(Vec::new()));
 
-    TestNetworkWorker {
+    let network_task_handle = TestNetworkWorker {
         network_status,
         rx_new_transaction: Some(rx_new_transaction),
         tx_new_transactions,
@@ -82,6 +85,7 @@ pub fn spawn_network(
     .spawn();
 
     TestNetwork {
+        network_task_handle,
         tx_new_transaction,
         network_status: tx_network_status,
         offline_destinations,
@@ -104,7 +108,8 @@ impl NetworkStatus {
 }
 
 pub struct TestNetwork {
-    tx_new_transaction: mpsc::Sender<(TestNetworkDestination, ExecutedTransaction)>,
+    network_task_handle: task::JoinHandle<()>,
+    tx_new_transaction: mpsc::Sender<(TestNetworkDestination, TransactionRecord)>,
     network_status: watch::Sender<NetworkStatus>,
     offline_destinations: Arc<RwLock<Vec<TestNetworkDestination>>>,
     num_sent_messages: Arc<AtomicUsize>,
@@ -117,6 +122,10 @@ impl TestNetwork {
         self.network_status.send(NetworkStatus::Started).unwrap();
     }
 
+    pub fn task_handle(&self) -> &task::JoinHandle<()> {
+        &self.network_task_handle
+    }
+
     pub async fn go_offline(&self, destination: TestNetworkDestination) -> &Self {
         if destination.is_bucket() {
             unimplemented!("Sorry :/ taking a bucket offline is not yet supported in the test harness");
@@ -136,7 +145,7 @@ impl TestNetwork {
         self.network_status.send(NetworkStatus::Paused).unwrap();
     }
 
-    pub async fn send_transaction(&self, destination: TestNetworkDestination, tx: ExecutedTransaction) {
+    pub async fn send_transaction(&self, destination: TestNetworkDestination, tx: TransactionRecord) {
         self.tx_new_transaction.send((destination, tx)).await.unwrap();
     }
 
@@ -171,7 +180,7 @@ impl TestNetworkDestination {
 }
 
 pub struct TestNetworkWorker {
-    rx_new_transaction: Option<mpsc::Receiver<(TestNetworkDestination, ExecutedTransaction)>>,
+    rx_new_transaction: Option<mpsc::Receiver<(TestNetworkDestination, TransactionRecord)>>,
     #[allow(clippy::type_complexity)]
     tx_new_transactions: HashMap<
         TestAddress,
@@ -191,7 +200,7 @@ pub struct TestNetworkWorker {
     on_message: watch::Sender<Option<HotstuffMessage>>,
     num_sent_messages: Arc<AtomicUsize>,
     num_filtered_messages: Arc<AtomicUsize>,
-    transaction_store: Arc<RwLock<HashMap<TransactionId, ExecutedTransaction>>>,
+    transaction_store: Arc<RwLock<HashMap<TransactionId, TransactionRecord>>>,
 
     offline_destinations: Arc<RwLock<Vec<TestNetworkDestination>>>,
     shutdown_signal: ShutdownSignal,
@@ -199,8 +208,8 @@ pub struct TestNetworkWorker {
 }
 
 impl TestNetworkWorker {
-    pub fn spawn(self) {
-        tokio::spawn(self.run());
+    pub fn spawn(self) -> task::JoinHandle<()> {
+        tokio::spawn(self.run())
     }
 
     async fn run(mut self) {
@@ -213,18 +222,20 @@ impl TestNetworkWorker {
         let transaction_store = self.transaction_store.clone();
 
         // Handle transactions that come in from the test. This behaves like a mempool.
-        tokio::spawn(async move {
-            while let Some((dest, executed)) = rx_new_transaction.recv().await {
+        let mut mempool_task = tokio::spawn(async move {
+            while let Some((dest, tx_record)) = rx_new_transaction.recv().await {
                 transaction_store
                     .write()
                     .await
-                    .insert(*executed.transaction().id(), executed.clone());
+                    .insert(*tx_record.transaction().id(), tx_record.clone());
                 for (addr, (bucket, tx_new_transaction_to_consensus, state_store)) in &tx_new_transactions {
                     if dest.is_for(addr, *bucket) {
                         state_store
                             .with_write_tx(|tx| {
-                                executed.upsert(tx)?;
-                                let atom = executed.to_atom();
+                                tx_record.upsert(tx)?;
+                                // Inserting in the pool here allows us to wait for all transactions have made it to
+                                // consensus before starting consensus.
+                                let atom = tx_record.to_atom();
                                 let pool = TransactionPool::<SqliteStateStore<TestAddress>>::new();
                                 if !pool.exists(tx, &atom.id)? {
                                     pool.insert(tx, atom)?;
@@ -232,8 +243,11 @@ impl TestNetworkWorker {
                                 Ok::<_, anyhow::Error>(())
                             })
                             .unwrap();
-                        log::info!("🐞 New transaction {}", executed.id());
-                        tx_new_transaction_to_consensus.send((*executed.id(), 0)).await.unwrap();
+                        log::info!("🐞 New transaction {}", tx_record.id());
+                        tx_new_transaction_to_consensus
+                            .send((*tx_record.id(), 0))
+                            .await
+                            .unwrap();
                     }
                 }
             }
@@ -269,6 +283,10 @@ impl TestNetworkWorker {
                   _ = self.shutdown_signal.wait() => {
                     break;
                 }
+                result = &mut mempool_task => {
+                    result.expect("Mempool task failed");
+                    break;
+                }
 
                 Ok(_) = self.network_status.changed() => {
                     if let NetworkStatus::Started = *self.network_status.borrow() {
@@ -346,20 +364,17 @@ impl TestNetworkWorker {
             .get(&from)
             .unwrap_or_else(|| panic!("No new transaction channel for {}", from));
 
-        // In the normal case, we need to provide the same execution results to consensus. In future we could add code
+        // In the normal case, we need to provide the same execution results to consensus. In future, we could add code
         // here to make a local decision to ABORT.
-        let existing_executed_tx = self.transaction_store.read().await.get(msg.id()).unwrap().clone();
+        let existing_tx = self.transaction_store.read().await.get(msg.id()).unwrap().clone();
         state_store
             .with_write_tx(|tx| {
-                existing_executed_tx.upsert(tx)?;
-                let pool = TransactionPool::<SqliteStateStore<TestAddress>>::new();
-                if !pool.exists(tx, existing_executed_tx.id())? {
-                    pool.insert(tx, existing_executed_tx.to_atom())?;
-                }
+                // Add the transaction from the store to the node's db
+                existing_tx.upsert(tx)?;
                 Ok::<_, anyhow::Error>(())
             })
             .unwrap();
 
-        sender.send((*existing_executed_tx.id(), 0)).await.unwrap();
+        sender.send((*existing_tx.id(), 0)).await.unwrap();
     }
 }
diff --git a/dan_layer/consensus_tests/src/support/transaction.rs b/dan_layer/consensus_tests/src/support/transaction.rs
index d6e95dc84..e7755d482 100644
--- a/dan_layer/consensus_tests/src/support/transaction.rs
+++ b/dan_layer/consensus_tests/src/support/transaction.rs
@@ -5,14 +5,14 @@ use std::{iter, time::Duration};
 
 use rand::{distributions::Alphanumeric, rngs::OsRng, Rng};
 use tari_common_types::types::PrivateKey;
-use tari_dan_storage::consensus_models::{Decision, ExecutedTransaction};
+use tari_dan_storage::consensus_models::{Decision, ExecutedTransaction, TransactionRecord};
 use tari_engine_types::{
     commit_result::{ExecuteResult, FinalizeResult, RejectReason, TransactionResult},
     component::{ComponentBody, ComponentHeader},
     fees::FeeReceipt,
     substate::{Substate, SubstateDiff},
 };
-use tari_transaction::{Transaction, VersionedSubstateId};
+use tari_transaction::{SubstateRequirement, Transaction, VersionedSubstateId};
 
 use crate::support::helpers::random_substate_in_bucket;
 
@@ -21,50 +21,49 @@ pub fn build_transaction_from(
     decision: Decision,
     fee: u64,
     resulting_outputs: Vec<VersionedSubstateId>,
-) -> ExecutedTransaction {
+) -> TransactionRecord {
     let tx_id = *tx.id();
-    ExecutedTransaction::new(
-        tx,
-        ExecuteResult {
-            finalize: FinalizeResult::new(
-                tx_id.into_array().into(),
-                vec![],
-                vec![],
-                if decision.is_commit() {
-                    let mut diff = SubstateDiff::new();
-                    for output in &resulting_outputs {
-                        let s = (0..100).map(|_| OsRng.sample(Alphanumeric) as char).collect::<String>();
-                        let random_state = tari_bor::to_value(&s).unwrap();
-                        diff.up(
-                            output.substate_id.clone(),
-                            Substate::new(0, ComponentHeader {
-                                template_address: Default::default(),
-                                module_name: "Test".to_string(),
-                                owner_key: Default::default(),
-                                owner_rule: Default::default(),
-                                access_rules: Default::default(),
-                                entity_id: output.substate_id.as_component_address().unwrap().entity_id(),
-                                body: ComponentBody { state: random_state },
-                            }),
-                        )
-                    }
-                    TransactionResult::Accept(diff)
-                } else {
-                    TransactionResult::Reject(RejectReason::ExecutionFailure("Test failure".to_string()))
-                },
-                FeeReceipt {
-                    total_fee_payment: fee.try_into().unwrap(),
-                    total_fees_paid: fee.try_into().unwrap(),
-                    cost_breakdown: vec![],
-                },
-            ),
-        },
-        resulting_outputs,
-        Duration::from_secs(0),
-    )
+    let result = if decision.is_commit() {
+        let mut diff = SubstateDiff::new();
+        for output in &resulting_outputs {
+            let s = (0..100).map(|_| OsRng.sample(Alphanumeric) as char).collect::<String>();
+            let random_state = tari_bor::to_value(&s).unwrap();
+            diff.up(
+                output.substate_id.clone(),
+                Substate::new(0, ComponentHeader {
+                    template_address: Default::default(),
+                    module_name: "Test".to_string(),
+                    owner_key: Default::default(),
+                    owner_rule: Default::default(),
+                    access_rules: Default::default(),
+                    entity_id: output.substate_id.as_component_address().unwrap().entity_id(),
+                    body: ComponentBody { state: random_state },
+                }),
+            )
+        }
+        TransactionResult::Accept(diff)
+    } else {
+        TransactionResult::Reject(RejectReason::ExecutionFailure("Test failure".to_string()))
+    };
+
+    let mut tx = TransactionRecord::new(tx);
+    tx.result = Some(ExecuteResult {
+        finalize: FinalizeResult::new(tx_id.into_array().into(), vec![], vec![], result, FeeReceipt {
+            total_fee_payment: fee.try_into().unwrap(),
+            total_fees_paid: fee.try_into().unwrap(),
+            cost_breakdown: vec![],
+        }),
+    });
+    tx.resulting_outputs = resulting_outputs;
+    tx.execution_time = Some(Duration::from_secs(0));
+    // If the transaction does not require any inputs, we immediately resolve them to an empty set
+    if tx.transaction.all_inputs_iter().next().is_none() {
+        tx.resolved_inputs = Some(Default::default());
+    }
+    tx
 }
 
-pub fn build_transaction(decision: Decision, fee: u64, num_shards: usize, num_committees: u32) -> ExecutedTransaction {
+pub fn build_transaction(decision: Decision, fee: u64, num_shards: usize, num_committees: u32) -> TransactionRecord {
     let k = PrivateKey::default();
     let tx = Transaction::builder().sign(&k).build();
 
@@ -80,7 +79,17 @@ pub fn build_transaction(decision: Decision, fee: u64, num_shards: usize, num_co
     build_transaction_from(tx, decision, fee, outputs)
 }
 
-pub fn change_decision(tx: ExecutedTransaction, new_decision: Decision) -> ExecutedTransaction {
+pub fn build_transaction_with_inputs<I: IntoIterator<Item = SubstateRequirement>>(
+    decision: Decision,
+    fee: u64,
+    inputs: I,
+) -> TransactionRecord {
+    let k = PrivateKey::default();
+    let tx = Transaction::builder().with_inputs(inputs).sign(&k).build();
+    build_transaction_from(tx, decision, fee, vec![])
+}
+
+pub fn change_decision(tx: ExecutedTransaction, new_decision: Decision) -> TransactionRecord {
     let total_fees_paid = tx
         .result()
         .finalize
diff --git a/dan_layer/consensus_tests/src/support/transaction_executor.rs b/dan_layer/consensus_tests/src/support/transaction_executor.rs
index e26885f69..a79a81519 100644
--- a/dan_layer/consensus_tests/src/support/transaction_executor.rs
+++ b/dan_layer/consensus_tests/src/support/transaction_executor.rs
@@ -21,8 +21,10 @@ impl TestBlockTransactionExecutorBuilder {
 impl<TStateStore> BlockTransactionExecutorBuilder<TStateStore> for TestBlockTransactionExecutorBuilder
 where TStateStore: StateStore
 {
-    fn build(&self) -> Box<dyn BlockTransactionExecutor<TStateStore>> {
-        Box::new(TestBlockTransactionProcessor::new())
+    type Executor = TestBlockTransactionProcessor;
+
+    fn build(&self) -> Self::Executor {
+        TestBlockTransactionProcessor::new()
     }
 }
 
diff --git a/dan_layer/engine/src/runtime/impl.rs b/dan_layer/engine/src/runtime/impl.rs
index 4d63b2e80..1e70b87c0 100644
--- a/dan_layer/engine/src/runtime/impl.rs
+++ b/dan_layer/engine/src/runtime/impl.rs
@@ -2118,10 +2118,10 @@ impl<TTemplateProvider: TemplateProvider<Template = LoadedTemplate>> RuntimeInte
         let unclaimed_output = self.tracker.take_unclaimed_confidential_output(output_address)?;
         // 2. owner_sig must be valid
         let challenge = ownership_proof_hasher64(self.network)
-            .chain_update(proof_of_knowledge.public_nonce())
-            .chain_update(&unclaimed_output.commitment)
-            .chain_update(&self.transaction_signer_public_key)
-            .result();
+            .chain(proof_of_knowledge.public_nonce())
+            .chain(&unclaimed_output.commitment)
+            .chain(&self.transaction_signer_public_key)
+            .finalize();
 
         if !proof_of_knowledge.verify_challenge(&unclaimed_output.commitment, &challenge, get_commitment_factory()) {
             warn!(target: LOG_TARGET, "Claim burn failed - Invalid signature");
diff --git a/dan_layer/engine/src/state_store/memory.rs b/dan_layer/engine/src/state_store/memory.rs
index 4a9ea668c..e49202c6f 100644
--- a/dan_layer/engine/src/state_store/memory.rs
+++ b/dan_layer/engine/src/state_store/memory.rs
@@ -42,13 +42,15 @@ impl MemoryStateStore {
         Self::default()
     }
 
-    pub fn set_all<T: IntoIterator<Item = (K, V)>, K: Serialize, V: Serialize>(&self, iter: T) {
-        // MemoryStateStore is infallible
-        let mut state = self.write_access().unwrap();
+    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).unwrap();
+            state.set_state(&k, v)?;
         }
-        state.commit().unwrap()
+        state.commit()
     }
 }
 
@@ -70,10 +72,12 @@ pub struct MemoryTransaction<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().map(|(k, v)| (k.as_slice(), v.as_slice())))
+        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())),
+        )
     }
 }
 
@@ -159,12 +163,6 @@ impl<'a> StateWriter for MemoryTransaction<RwLockWriteGuard<'a, InnerKvMap>> {
     }
 }
 
-impl<K: Serialize, V: Serialize> Extend<(K, V)> for MemoryStateStore {
-    fn extend<T: IntoIterator<Item = (K, V)>>(&mut self, iter: T) {
-        self.set_all(iter)
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use serde::{Deserialize, Serialize};
diff --git a/dan_layer/engine_types/Cargo.toml b/dan_layer/engine_types/Cargo.toml
index 18edcbdff..424a53c13 100644
--- a/dan_layer/engine_types/Cargo.toml
+++ b/dan_layer/engine_types/Cargo.toml
@@ -17,7 +17,6 @@ tari_template_abi = { workspace = true, features = ["std"] }
 tari_template_lib = { workspace = true }
 tari_utilities = { workspace = true }
 
-borsh = { workspace = true }
 # if we set this version in the workspace it would break other crates
 base64 = "0.21.0"
 blake2 = { workspace = true }
diff --git a/dan_layer/engine_types/src/base_layer_hashing.rs b/dan_layer/engine_types/src/base_layer_hashing.rs
index 8aec02380..b26d28d41 100644
--- a/dan_layer/engine_types/src/base_layer_hashing.rs
+++ b/dan_layer/engine_types/src/base_layer_hashing.rs
@@ -20,20 +20,16 @@
 //  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::{io, io::Write};
-
 use blake2::Blake2b;
-use borsh::BorshSerialize;
-use digest::{
-    consts::{U32, U64},
-    Digest,
-};
+use digest::consts::{U32, U64};
 use tari_common::configuration::Network;
-use tari_crypto::hashing::{DomainSeparatedHasher, DomainSeparation};
-use tari_hashing::{ConfidentialOutputHashDomain, WalletOutputEncryptionKeysDomain};
+use tari_crypto::hashing::DomainSeparatedHasher;
+use tari_hashing::{ConfidentialOutputHashDomain, DomainSeparatedBorshHasher, WalletOutputEncryptionKeysDomain};
 
-fn confidential_hasher64(network: Network, label: &'static str) -> TariBaseLayerHasher64 {
-    TariBaseLayerHasher64::new_with_label::<ConfidentialOutputHashDomain>(network, label)
+pub type TariBaseLayerHasher64<M> = DomainSeparatedBorshHasher<M, Blake2b<U64>>;
+pub type TariBaseLayerHasher32<M> = DomainSeparatedBorshHasher<M, Blake2b<U32>>;
+fn confidential_hasher64(network: Network, label: &'static str) -> TariBaseLayerHasher64<ConfidentialOutputHashDomain> {
+    DomainSeparatedBorshHasher::<_, Blake2b<U64>>::new_with_label(&format!("{}.n{}", label, network.as_byte()))
 }
 
 type WalletOutputEncryptionKeysDomainHasher = DomainSeparatedHasher<Blake2b<U64>, WalletOutputEncryptionKeysDomain>;
@@ -42,121 +38,6 @@ pub fn encrypted_data_hasher() -> WalletOutputEncryptionKeysDomainHasher {
     WalletOutputEncryptionKeysDomainHasher::new_with_label("")
 }
 
-pub fn ownership_proof_hasher64(network: Network) -> TariBaseLayerHasher64 {
+pub fn ownership_proof_hasher64(network: Network) -> TariBaseLayerHasher64<ConfidentialOutputHashDomain> {
     confidential_hasher64(network, "commitment_signature")
 }
-
-#[derive(Debug, Clone)]
-pub struct TariBaseLayerHasher64 {
-    hasher: Blake2b<U64>,
-}
-
-impl TariBaseLayerHasher64 {
-    pub fn new_with_label<TDomain: DomainSeparation>(network: Network, label: &'static str) -> Self {
-        let mut hasher = Blake2b::<U64>::new();
-        TDomain::add_domain_separation_tag(&mut hasher, &format!("{}.n{}", label, network.as_byte()));
-        Self { hasher }
-    }
-
-    pub fn from_digest(digest: Blake2b<U64>) -> Self {
-        Self { hasher: digest }
-    }
-
-    pub fn update<T: BorshSerialize>(&mut self, data: &T) {
-        BorshSerialize::serialize(data, &mut self.hash_writer())
-            .expect("Incorrect implementation of BorshSerialize encountered. Implementations MUST be infallible.");
-    }
-
-    pub fn chain<T: BorshSerialize>(mut self, data: &T) -> Self {
-        self.update(data);
-        self
-    }
-
-    pub fn chain_update<T: BorshSerialize>(self, data: &T) -> Self {
-        self.chain(data)
-    }
-
-    pub fn digest<T: BorshSerialize>(self, data: &T) -> [u8; 64] {
-        self.chain(data).result()
-    }
-
-    pub fn result(self) -> [u8; 64] {
-        self.hasher.finalize().into()
-    }
-
-    pub fn finalize_into(self, output: &mut digest::Output<Blake2b<U64>>) {
-        digest::FixedOutput::finalize_into(self.hasher, output)
-    }
-
-    fn hash_writer(&mut self) -> impl Write + '_ {
-        struct HashWriter<'a>(&'a mut Blake2b<U64>);
-        impl Write for HashWriter<'_> {
-            fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-                self.0.update(buf);
-                Ok(buf.len())
-            }
-
-            fn flush(&mut self) -> io::Result<()> {
-                Ok(())
-            }
-        }
-        HashWriter(&mut self.hasher)
-    }
-}
-#[derive(Debug, Clone)]
-pub struct TariBaseLayerHasher32 {
-    hasher: Blake2b<U32>,
-}
-
-impl TariBaseLayerHasher32 {
-    pub fn new_with_label<TDomain: DomainSeparation>(network: Network, label: &'static str) -> Self {
-        let mut hasher = Blake2b::<U32>::new();
-        TDomain::add_domain_separation_tag(&mut hasher, &format!("{}.n{}", label, network.as_byte()));
-        Self { hasher }
-    }
-
-    pub fn from_digest(digest: Blake2b<U32>) -> Self {
-        Self { hasher: digest }
-    }
-
-    pub fn update<T: BorshSerialize>(&mut self, data: &T) {
-        BorshSerialize::serialize(data, &mut self.hash_writer())
-            .expect("Incorrect implementation of BorshSerialize encountered. Implementations MUST be infallible.");
-    }
-
-    pub fn chain<T: BorshSerialize>(mut self, data: &T) -> Self {
-        self.update(data);
-        self
-    }
-
-    pub fn chain_update<T: BorshSerialize>(self, data: &T) -> Self {
-        self.chain(data)
-    }
-
-    pub fn digest<T: BorshSerialize>(self, data: &T) -> [u8; 32] {
-        self.chain(data).result()
-    }
-
-    pub fn result(self) -> [u8; 32] {
-        self.hasher.finalize().into()
-    }
-
-    pub fn finalize_into(self, output: &mut digest::Output<Blake2b<U32>>) {
-        digest::FixedOutput::finalize_into(self.hasher, output)
-    }
-
-    fn hash_writer(&mut self) -> impl Write + '_ {
-        struct HashWriter<'a>(&'a mut Blake2b<U32>);
-        impl Write for HashWriter<'_> {
-            fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-                self.0.update(buf);
-                Ok(buf.len())
-            }
-
-            fn flush(&mut self) -> io::Result<()> {
-                Ok(())
-            }
-        }
-        HashWriter(&mut self.hasher)
-    }
-}
diff --git a/dan_layer/engine_types/src/commit_result.rs b/dan_layer/engine_types/src/commit_result.rs
index 264fe5114..0599a6b7d 100644
--- a/dan_layer/engine_types/src/commit_result.rs
+++ b/dan_layer/engine_types/src/commit_result.rs
@@ -145,6 +145,8 @@ impl FinalizeResult {
         }
     }
 
+    /// Returns the accept diff if the transaction was accepted, otherwise None.
+    /// Acceptance includes fee-only acceptance.
     pub fn accept(&self) -> Option<&SubstateDiff> {
         self.result.accept()
     }
diff --git a/dan_layer/epoch_manager/src/validator_node.rs b/dan_layer/epoch_manager/src/validator_node.rs
deleted file mode 100644
index 5d27a0631..000000000
--- a/dan_layer/epoch_manager/src/validator_node.rs
+++ /dev/null
@@ -1,52 +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 serde::Serialize;
-// use tari_common_types::types::FixedHash;
-// use tari_dan_common_types::{vn_node_hash, NodeAddressable, SubstateAddress};
-//
-// #[derive(Clone, Debug, PartialEq, Eq, Serialize)]
-// pub struct ValidatorNode<TAddr> {
-//     pub shard_key: SubstateAddress,
-//     pub public_key: TAddr,
-// }
-//
-// impl<TAddr: NodeAddressable> ValidatorNode<TAddr> {
-//     pub fn node_hash(&self) -> FixedHash {
-//         vn_node_hash(&self.public_key, &self.shard_key)
-//     }
-// }
-use tari_common_types::types::FixedHash;
-use tari_dan_common_types::{vn_node_hash, Epoch, NodeAddressable, SubstateAddress};
-
-#[derive(Debug, Clone)]
-pub struct ValidatorNode<TAddr> {
-    pub address: TAddr,
-    pub shard_key: SubstateAddress,
-    pub epoch: Epoch,
-}
-
-impl<TAddr: NodeAddressable> ValidatorNode<TAddr> {
-    pub fn node_hash(&self) -> FixedHash {
-        vn_node_hash(&self.address, &self.shard_key)
-    }
-}
diff --git a/dan_layer/indexer_lib/Cargo.toml b/dan_layer/indexer_lib/Cargo.toml
index c83b6000f..3199176ee 100644
--- a/dan_layer/indexer_lib/Cargo.toml
+++ b/dan_layer/indexer_lib/Cargo.toml
@@ -17,14 +17,9 @@ tari_validator_node_rpc = { workspace = true }
 tari_dan_storage = { workspace = true }
 
 async-trait = { workspace = true }
+futures = { workspace = true }
 log = { workspace = true }
 serde = { workspace = true, default-features = true }
 rand = { workspace = true }
 thiserror = { workspace = true }
-tokio = { workspace = true, features = [
-    "default",
-    "macros",
-    "time",
-    "sync",
-    "rt-multi-thread",
-] }
+tokio = { workspace = true, features = ["default", "macros", "time", "sync", "rt-multi-thread"] }
diff --git a/dan_layer/indexer_lib/src/transaction_autofiller.rs b/dan_layer/indexer_lib/src/transaction_autofiller.rs
index cf3dd47a7..a16b93a37 100644
--- a/dan_layer/indexer_lib/src/transaction_autofiller.rs
+++ b/dan_layer/indexer_lib/src/transaction_autofiller.rs
@@ -3,6 +3,7 @@
 
 use std::{collections::HashMap, sync::Arc};
 
+use futures::{stream::FuturesOrdered, StreamExt};
 use log::*;
 use tari_dan_common_types::NodeAddressable;
 use tari_engine_types::{
@@ -10,7 +11,7 @@ use tari_engine_types::{
     substate::{Substate, SubstateId},
 };
 use tari_epoch_manager::EpochManagerReader;
-use tari_transaction::{SubstateRequirement, Transaction};
+use tari_transaction::{SubstateRequirement, Transaction, VersionedSubstateId};
 use tari_validator_node_rpc::client::{SubstateResult, ValidatorNodeClientFactory};
 use tokio::task::JoinError;
 
@@ -58,33 +59,27 @@ where
         let mut autofilled_transaction = original_transaction;
 
         // scan the network in parallel to fetch all the substates for each required input
-        let mut input_shards = vec![];
+        let mut versioned_inputs = vec![];
         let mut found_substates = HashMap::new();
         let substate_scanner_ref = self.substate_scanner.clone();
         let transaction_ref = Arc::new(autofilled_transaction.clone());
-        let mut handles = Vec::new();
+        let mut tasks = FuturesOrdered::new();
         for requirement in &substate_requirements {
-            let handle = tokio::spawn(get_substate_requirement(
+            tasks.push_back(get_substate_requirement(
                 substate_scanner_ref.clone(),
                 transaction_ref.clone(),
                 requirement.clone(),
             ));
-            handles.push(handle);
         }
-        for handle in handles {
-            let res = handle.await??;
-            if let Some((address, substate)) = res {
-                let shard = SubstateRequirement::new(address.clone(), Some(substate.version()));
-                if autofilled_transaction.input_refs().contains(&shard) {
-                    // Shard is already an input as a ref
-                    continue;
-                }
-                input_shards.push(shard);
+        while let Some(result) = tasks.next().await {
+            if let Some((address, substate)) = result? {
+                let versioned_substate_id = VersionedSubstateId::new(address.clone(), substate.version());
+                versioned_inputs.push(versioned_substate_id);
                 found_substates.insert(address, substate);
             }
         }
         info!(target: LOG_TARGET, "✏️️ Found {} input substates", found_substates.len());
-        autofilled_transaction.filled_inputs_mut().extend(input_shards);
+        autofilled_transaction.filled_inputs_mut().extend(versioned_inputs);
 
         // let mut found_this_round = 0;
 
@@ -125,15 +120,7 @@ where
                         id,
                         substate.version()
                     );
-                    let substate_requirement = SubstateRequirement::new(id.clone(), Some(substate.version()));
-                    if autofilled_transaction
-                        .all_inputs_iter()
-                        .any(|s| *s == substate_requirement)
-                    {
-                        // Shard is already an input (TODO: what a waste)
-                        continue;
-                    }
-                    autofilled_inputs.push(SubstateRequirement::new(id, Some(substate.version())));
+                    autofilled_inputs.push(VersionedSubstateId::new(id, substate.version()));
                     found_substates.insert(address, substate);
                 //       found_this_round += 1;
                 } else {
@@ -165,14 +152,16 @@ where
     TAddr: NodeAddressable,
     TSubstateCache: SubstateCache,
 {
+    if transaction
+        .all_inputs_iter()
+        .any(|s| s.version.is_some() && s.substate_id == *req.substate_id())
+    {
+        // Input for this substate has a specified version, so we do not autofill it
+        return Ok(None);
+    }
+
     let mut version = req.version().unwrap_or(0);
     loop {
-        let shard = SubstateRequirement::new(req.substate_id().clone(), Some(version));
-        if transaction.all_inputs_iter().any(|s| *s == shard) {
-            // Shard is already an input
-            return Ok(None);
-        }
-
         let scan_res = substate_scanner.get_substate(req.substate_id(), Some(version)).await?;
 
         match scan_res {
@@ -187,11 +176,6 @@ where
                     id,
                     substate.version()
                 );
-                let shard = SubstateRequirement::new(req.substate_id().clone(), Some(version));
-                if transaction.all_inputs_iter().any(|s| *s == shard) {
-                    // Shard is already an input (TODO: what a waste)
-                    return Ok(None);
-                }
 
                 return Ok(Some((id, substate)));
             },
diff --git a/dan_layer/p2p/proto/consensus.proto b/dan_layer/p2p/proto/consensus.proto
index 94deb45f6..5f308e4cf 100644
--- a/dan_layer/p2p/proto/consensus.proto
+++ b/dan_layer/p2p/proto/consensus.proto
@@ -108,6 +108,7 @@ enum Decision {
   UNKNOWN = 0;
   COMMIT = 1;
   ABORT = 2;
+  DEFERRED = 3;
 }
 
 message Evidence {
diff --git a/dan_layer/p2p/proto/transaction.proto b/dan_layer/p2p/proto/transaction.proto
index 4f915bc7b..cc496c221 100644
--- a/dan_layer/p2p/proto/transaction.proto
+++ b/dan_layer/p2p/proto/transaction.proto
@@ -23,10 +23,9 @@ message Transaction {
   repeated Instruction instructions = 2;
   tari.dan.common.SignatureAndPublicKey signature = 3;
   repeated SubstateRequirement inputs = 4;
-  repeated SubstateRequirement input_refs = 5;
-  repeated SubstateRequirement filled_inputs = 7;
-  tari.dan.common.Epoch min_epoch = 8;
-  tari.dan.common.Epoch max_epoch = 9;
+  repeated VersionedSubstateId filled_inputs = 5;
+  tari.dan.common.Epoch min_epoch = 6;
+  tari.dan.common.Epoch max_epoch = 7;
 }
 
 message Instruction {
@@ -95,6 +94,11 @@ message OptionalVersion {
   uint32 version = 1;
 }
 
+message VersionedSubstateId {
+  bytes substate_id = 1;
+  uint32 version = 2;
+}
+
 message ConfidentialWithdrawProof {
   repeated bytes inputs = 1;
   uint64 input_revealed_amount = 2;
diff --git a/dan_layer/p2p/src/conversions/consensus.rs b/dan_layer/p2p/src/conversions/consensus.rs
index 8726f7c0e..1e3d53f42 100644
--- a/dan_layer/p2p/src/conversions/consensus.rs
+++ b/dan_layer/p2p/src/conversions/consensus.rs
@@ -500,6 +500,7 @@ impl From<Decision> for proto::consensus::Decision {
         match value {
             Decision::Commit => proto::consensus::Decision::Commit,
             Decision::Abort => proto::consensus::Decision::Abort,
+            Decision::Deferred => proto::consensus::Decision::Deferred,
         }
     }
 }
@@ -511,6 +512,7 @@ impl TryFrom<proto::consensus::Decision> for Decision {
         match value {
             proto::consensus::Decision::Commit => Ok(Decision::Commit),
             proto::consensus::Decision::Abort => Ok(Decision::Abort),
+            proto::consensus::Decision::Deferred => Ok(Decision::Deferred),
             proto::consensus::Decision::Unknown => Err(anyhow!("Decision not provided")),
         }
     }
diff --git a/dan_layer/p2p/src/conversions/transaction.rs b/dan_layer/p2p/src/conversions/transaction.rs
index 88e0a770b..6ef5e7e14 100644
--- a/dan_layer/p2p/src/conversions/transaction.rs
+++ b/dan_layer/p2p/src/conversions/transaction.rs
@@ -44,7 +44,7 @@ use tari_template_lib::{
         ViewableBalanceProof,
     },
 };
-use tari_transaction::{SubstateRequirement, Transaction};
+use tari_transaction::{SubstateRequirement, Transaction, VersionedSubstateId};
 
 use crate::{
     proto::{
@@ -108,11 +108,6 @@ impl TryFrom<proto::transaction::Transaction> for Transaction {
             .into_iter()
             .map(TryInto::try_into)
             .collect::<Result<_, _>>()?;
-        let input_refs = request
-            .input_refs
-            .into_iter()
-            .map(TryInto::try_into)
-            .collect::<Result<_, _>>()?;
         let filled_inputs = request
             .filled_inputs
             .into_iter()
@@ -125,7 +120,6 @@ impl TryFrom<proto::transaction::Transaction> for Transaction {
             instructions,
             signature,
             inputs,
-            input_refs,
             filled_inputs,
             min_epoch,
             max_epoch,
@@ -139,7 +133,6 @@ impl From<&Transaction> for proto::transaction::Transaction {
     fn from(transaction: &Transaction) -> Self {
         let signature = transaction.signature().clone().into();
         let inputs = transaction.inputs().iter().map(Into::into).collect();
-        let input_refs = transaction.input_refs().iter().map(Into::into).collect();
         let filled_inputs = transaction.filled_inputs().iter().map(Into::into).collect();
         let fee_instructions = transaction.fee_instructions().to_vec();
         let instructions = transaction.instructions().to_vec();
@@ -156,7 +149,6 @@ impl From<&Transaction> for proto::transaction::Transaction {
             instructions,
             signature: Some(signature),
             inputs,
-            input_refs,
             filled_inputs,
             min_epoch,
             max_epoch,
@@ -371,6 +363,12 @@ impl TryFrom<proto::transaction::SubstateRequirement> for SubstateRequirement {
 
 impl From<SubstateRequirement> for proto::transaction::SubstateRequirement {
     fn from(val: SubstateRequirement) -> Self {
+        (&val).into()
+    }
+}
+
+impl From<&SubstateRequirement> for proto::transaction::SubstateRequirement {
+    fn from(val: &SubstateRequirement) -> Self {
         Self {
             substate_id: val.substate_id().to_bytes(),
             version: val.version().map(|v| OptionalVersion { version: v }),
@@ -378,11 +376,29 @@ impl From<SubstateRequirement> for proto::transaction::SubstateRequirement {
     }
 }
 
-impl From<&SubstateRequirement> for proto::transaction::SubstateRequirement {
-    fn from(val: &SubstateRequirement) -> Self {
+// -------------------------------- VersionedSubstate -------------------------------- //
+
+impl TryFrom<proto::transaction::VersionedSubstateId> for VersionedSubstateId {
+    type Error = anyhow::Error;
+
+    fn try_from(val: proto::transaction::VersionedSubstateId) -> Result<Self, Self::Error> {
+        let substate_id = SubstateId::from_bytes(&val.substate_id)?;
+        let substate_specification = VersionedSubstateId::new(substate_id, val.version);
+        Ok(substate_specification)
+    }
+}
+
+impl From<VersionedSubstateId> for proto::transaction::VersionedSubstateId {
+    fn from(val: VersionedSubstateId) -> Self {
+        (&val).into()
+    }
+}
+
+impl From<&VersionedSubstateId> for proto::transaction::VersionedSubstateId {
+    fn from(val: &VersionedSubstateId) -> Self {
         Self {
             substate_id: val.substate_id().to_bytes(),
-            version: val.version().map(|v| OptionalVersion { version: v }),
+            version: val.version,
         }
     }
 }
diff --git a/dan_layer/state_store_sqlite/migrations/2023-06-08-091819_create_state_store/up.sql b/dan_layer/state_store_sqlite/migrations/2023-06-08-091819_create_state_store/up.sql
index fd66ecc1b..934511987 100644
--- a/dan_layer/state_store_sqlite/migrations/2023-06-08-091819_create_state_store/up.sql
+++ b/dan_layer/state_store_sqlite/migrations/2023-06-08-091819_create_state_store/up.sql
@@ -12,26 +12,26 @@ create unique index quorum_certificates_uniq_idx_id on quorum_certificates (qc_i
 
 create table blocks
 (
-    id                    integer   not null primary key AUTOINCREMENT,
-    block_id              text      not NULL,
-    parent_block_id       text      not NULL,
-    merkle_root           text      not NULL,
-    network               text      not NULL,
-    height                bigint    not NULL,
-    epoch                 bigint    not NULL,
-    shard                 integer   not NULL,
-    proposed_by           text      not NULL,
-    qc_id                 text      not NULL,
-    command_count         bigint    not NULL,
-    commands              text      not NULL,
-    total_leader_fee      bigint    not NULL,
-    is_committed          boolean   not NULL default '0',
-    is_processed          boolean   not NULL,
-    is_dummy              boolean   not NULL,
-    foreign_indexes       text      not NULL,
-    signature             text      NULL,
-    block_time            bigint    NULL,
-    timestamp             bigint    not NULL,
+    id                      integer   not null primary key AUTOINCREMENT,
+    block_id                text      not NULL,
+    parent_block_id         text      not NULL,
+    merkle_root             text      not NULL,
+    network                 text      not NULL,
+    height                  bigint    not NULL,
+    epoch                   bigint    not NULL,
+    shard                   integer   not NULL,
+    proposed_by             text      not NULL,
+    qc_id                   text      not NULL,
+    command_count           bigint    not NULL,
+    commands                text      not NULL,
+    total_leader_fee        bigint    not NULL,
+    is_committed            boolean   not NULL default '0',
+    is_processed            boolean   not NULL,
+    is_dummy                boolean   not NULL,
+    foreign_indexes         text      not NULL,
+    signature               text      NULL,
+    block_time              bigint    NULL,
+    timestamp               bigint    not NULL,
     base_layer_block_height bigint    not NULL,
     base_layer_block_hash   text      not NULL,
     created_at              timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
@@ -42,27 +42,27 @@ create table blocks
 create unique index blocks_uniq_idx_id on blocks (block_id);
 
 create table parked_blocks
-(   
-    id                    integer not null primary key AUTOINCREMENT,
-    block_id              text    not NULL,
-    parent_block_id       text    not NULL,
-    merkle_root           text    not NULL,
-    network               text    not NULL,
-    height                bigint  not NULL,
-    epoch                 bigint  not NULL,
-    shard                 integer not NULL,
-    proposed_by           text    not NULL,
-    justify               text    not NULL,
-    command_count         bigint  not NULL,
-    commands              text    not NULL,
-    total_leader_fee      bigint  not NULL,
-    foreign_indexes       text    not NULL,
-    signature             text        NULL,
-    block_time            bigint      NULL,
-    timestamp             bigint  not NULL,
+(
+    id                      integer   not null primary key AUTOINCREMENT,
+    block_id                text      not NULL,
+    parent_block_id         text      not NULL,
+    merkle_root             text      not NULL,
+    network                 text      not NULL,
+    height                  bigint    not NULL,
+    epoch                   bigint    not NULL,
+    shard                   integer   not NULL,
+    proposed_by             text      not NULL,
+    justify                 text      not NULL,
+    command_count           bigint    not NULL,
+    commands                text      not NULL,
+    total_leader_fee        bigint    not NULL,
+    foreign_indexes         text      not NULL,
+    signature               text      NULL,
+    block_time              bigint    NULL,
+    timestamp               bigint    not NULL,
     base_layer_block_height bigint    not NULL,
-    base_layer_block_hash text    not NULL,
-    created_at            timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP
+    base_layer_block_hash   text      not NULL,
+    created_at              timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP
 );
 
 -- block_id must be unique. Optimise fetching by block_id
@@ -174,8 +174,8 @@ create table transactions
     instructions      text      not NULL,
     signature         text      not NULL,
     inputs            text      not NULL,
-    input_refs        text      not NULL,
     filled_inputs     text      not NULL,
+    resolved_inputs   text      NULL,
     resulting_outputs text      NULL,
     result            text      NULL,
     execution_time_ms bigint    NULL,
@@ -269,7 +269,7 @@ CREATE TABLE foreign_proposals
     bucket                  int       not NULL,
     block_id                text      not NULL,
     state                   text      not NULL,
-    proposed_height         bigint        NULL,
+    proposed_height         bigint    NULL,
     transactions            text      not NULL,
     base_layer_block_height bigint    not NULL,
     created_at              timestamp not NULL DEFAULT CURRENT_TIMESTAMP,
diff --git a/dan_layer/state_store_sqlite/src/reader.rs b/dan_layer/state_store_sqlite/src/reader.rs
index f7d2b4098..b15afc92c 100644
--- a/dan_layer/state_store_sqlite/src/reader.rs
+++ b/dan_layer/state_store_sqlite/src/reader.rs
@@ -1374,25 +1374,38 @@ impl<'tx, TAddr: NodeAddressable + Serialize + DeserializeOwned + 'tx> StateStor
 
         let tx_ids = transaction_ids.into_iter().map(serialize_hex).collect::<Vec<_>>();
 
-        let involved_shards = transactions::table
-            .select((transactions::inputs, transactions::input_refs))
-            .filter(transactions::transaction_id.eq_any(tx_ids))
-            .load::<(String, String)>(self.connection())
+        let inputs_per_tx = transactions::table
+            .select(transactions::resolved_inputs)
+            .filter(transactions::transaction_id.eq_any(&tx_ids))
+            .load::<Option<String>>(self.connection())
             .map_err(|e| SqliteStorageError::DieselError {
                 operation: "transaction_pools_fetch_involved_shards",
                 source: e,
             })?;
 
-        let shards = involved_shards
+        if inputs_per_tx.len() != tx_ids.len() {
+            return Err(SqliteStorageError::NotAllItemsFound {
+                items: "Transactions",
+                operation: "transactions_fetch_involved_shards",
+                details: format!(
+                    "transactions_fetch_involved_shards: expected {} transactions, got {}",
+                    tx_ids.len(),
+                    inputs_per_tx.len()
+                ),
+            }
+            .into());
+        }
+
+        let shards = inputs_per_tx
             .into_iter()
-            .map(|(inputs, input_refs)| {
-                (
-                    // a Result is very inconvenient with flat_map
-                    deserialize_json::<HashSet<SubstateAddress>>(&inputs).unwrap(),
-                    deserialize_json::<HashSet<SubstateAddress>>(&input_refs).unwrap(),
-                )
+            .filter_map(|inputs| {
+                // a Result is very inconvenient with flat_map
+                inputs.map(|inputs| {
+                    deserialize_json::<HashSet<SubstateAddress>>(&inputs)
+                        .expect("[transactions_fetch_involved_shards] Failed to deserialize involved shards")
+                })
             })
-            .flat_map(|(inputs, input_refs)| inputs.into_iter().chain(input_refs).collect::<HashSet<_>>())
+            .flatten()
             .collect();
 
         Ok(shards)
@@ -1627,7 +1640,7 @@ impl<'tx, TAddr: NodeAddressable + Serialize + DeserializeOwned + 'tx> StateStor
         Ok(substates)
     }
 
-    fn substates_check_lock_many<'a, I: IntoIterator<Item = &'a SubstateAddress>>(
+    fn substates_check_lock_many<B: Borrow<SubstateAddress>, I: IntoIterator<Item = B>>(
         &mut self,
         objects: I,
         lock_flag: SubstateLockFlag,
@@ -1635,7 +1648,10 @@ impl<'tx, TAddr: NodeAddressable + Serialize + DeserializeOwned + 'tx> StateStor
         use crate::schema::substates;
 
         // Lock unique shards
-        let objects: HashSet<String> = objects.into_iter().map(serialize_hex).collect();
+        let objects = objects
+            .into_iter()
+            .map(|v| serialize_hex(v.borrow()))
+            .collect::<HashSet<_>>();
 
         let locked_details = substates::table
             .select((substates::is_locked_w, substates::destroyed_by_transaction))
diff --git a/dan_layer/state_store_sqlite/src/schema.rs b/dan_layer/state_store_sqlite/src/schema.rs
index 6f9d3b938..50d94cea3 100644
--- a/dan_layer/state_store_sqlite/src/schema.rs
+++ b/dan_layer/state_store_sqlite/src/schema.rs
@@ -20,11 +20,11 @@ diesel::table! {
         is_dummy -> Bool,
         foreign_indexes -> Text,
         signature -> Nullable<Text>,
-        created_at -> Timestamp,
         block_time -> Nullable<BigInt>,
         timestamp -> BigInt,
         base_layer_block_height -> BigInt,
         base_layer_block_hash -> Text,
+        created_at -> Timestamp,
     }
 }
 
@@ -163,11 +163,11 @@ diesel::table! {
         total_leader_fee -> BigInt,
         foreign_indexes -> Text,
         signature -> Nullable<Text>,
-        created_at -> Timestamp,
         block_time -> Nullable<BigInt>,
         timestamp -> BigInt,
         base_layer_block_height -> BigInt,
         base_layer_block_hash -> Text,
+        created_at -> Timestamp,
     }
 }
 
@@ -289,8 +289,8 @@ diesel::table! {
         instructions -> Text,
         signature -> Text,
         inputs -> Text,
-        input_refs -> Text,
         filled_inputs -> Text,
+        resolved_inputs -> Nullable<Text>,
         resulting_outputs -> Nullable<Text>,
         result -> Nullable<Text>,
         execution_time_ms -> Nullable<BigInt>,
diff --git a/dan_layer/state_store_sqlite/src/sql_models/block.rs b/dan_layer/state_store_sqlite/src/sql_models/block.rs
index 662ee7f5e..3440a22eb 100644
--- a/dan_layer/state_store_sqlite/src/sql_models/block.rs
+++ b/dan_layer/state_store_sqlite/src/sql_models/block.rs
@@ -34,11 +34,11 @@ pub struct Block {
     pub is_dummy: bool,
     pub foreign_indexes: String,
     pub signature: Option<String>,
-    pub created_at: PrimitiveDateTime,
     pub block_time: Option<i64>,
     pub timestamp: i64,
     pub base_layer_block_height: i64,
     pub base_layer_block_hash: String,
+    pub created_at: PrimitiveDateTime,
 }
 
 impl Block {
@@ -97,11 +97,11 @@ pub struct ParkedBlock {
     pub total_leader_fee: i64,
     pub foreign_indexes: String,
     pub signature: Option<String>,
-    pub created_at: PrimitiveDateTime,
     pub block_time: Option<i64>,
     pub timestamp: i64,
     pub base_layer_block_height: i64,
     pub base_layer_block_hash: String,
+    pub created_at: PrimitiveDateTime,
 }
 
 impl TryFrom<ParkedBlock> for consensus_models::Block {
diff --git a/dan_layer/state_store_sqlite/src/sql_models/transaction.rs b/dan_layer/state_store_sqlite/src/sql_models/transaction.rs
index 38f80e10c..aa45094a4 100644
--- a/dan_layer/state_store_sqlite/src/sql_models/transaction.rs
+++ b/dan_layer/state_store_sqlite/src/sql_models/transaction.rs
@@ -18,8 +18,8 @@ pub struct Transaction {
     pub instructions: String,
     pub signature: String,
     pub inputs: String,
-    pub input_refs: String,
     pub filled_inputs: String,
+    pub resolved_inputs: Option<String>,
     pub resulting_outputs: Option<String>,
     pub result: Option<String>,
     pub execution_time_ms: Option<i64>,
@@ -40,7 +40,7 @@ impl TryFrom<Transaction> for tari_transaction::Transaction {
         let signature = deserialize_json(&value.signature)?;
 
         let inputs = deserialize_json(&value.inputs)?;
-        let input_refs = deserialize_json(&value.input_refs)?;
+
         let filled_inputs = deserialize_json(&value.filled_inputs)?;
         let min_epoch = value.min_epoch.map(|epoch| Epoch(epoch as u64));
         let max_epoch = value.max_epoch.map(|epoch| Epoch(epoch as u64));
@@ -50,7 +50,6 @@ impl TryFrom<Transaction> for tari_transaction::Transaction {
             instructions,
             signature,
             inputs,
-            input_refs,
             filled_inputs,
             min_epoch,
             max_epoch,
@@ -83,6 +82,7 @@ impl TryFrom<Transaction> for consensus_models::TransactionRecord {
             .map(deserialize_json)
             .transpose()?
             .unwrap_or_default();
+        let resolved_inputs = value.resolved_inputs.as_deref().map(deserialize_json).transpose()?;
         let abort_details = value.abort_details.clone();
 
         let finalized_time = value
@@ -93,6 +93,7 @@ impl TryFrom<Transaction> for consensus_models::TransactionRecord {
         Ok(Self::load(
             value.try_into()?,
             result,
+            resolved_inputs,
             execution_time,
             final_decision,
             finalized_time,
diff --git a/dan_layer/state_store_sqlite/src/writer.rs b/dan_layer/state_store_sqlite/src/writer.rs
index f63125bd8..a7e14811f 100644
--- a/dan_layer/state_store_sqlite/src/writer.rs
+++ b/dan_layer/state_store_sqlite/src/writer.rs
@@ -51,7 +51,7 @@ use tari_dan_storage::{
     StateStoreWriteTransaction,
     StorageError,
 };
-use tari_transaction::{Transaction, TransactionId, VersionedSubstateId};
+use tari_transaction::{TransactionId, VersionedSubstateId};
 use tari_utilities::ByteArray;
 use time::{OffsetDateTime, PrimitiveDateTime};
 
@@ -556,18 +556,37 @@ impl<'tx, TAddr: NodeAddressable + 'tx> StateStoreWriteTransaction for SqliteSta
         Ok(())
     }
 
-    fn transactions_insert(&mut self, transaction: &Transaction) -> Result<(), StorageError> {
+    fn transactions_insert(&mut self, tx_rec: &TransactionRecord) -> Result<(), StorageError> {
         use crate::schema::transactions;
 
+        let transaction = tx_rec.transaction();
         let insert = (
             transactions::transaction_id.eq(serialize_hex(transaction.id())),
             transactions::fee_instructions.eq(serialize_json(transaction.fee_instructions())?),
             transactions::instructions.eq(serialize_json(transaction.instructions())?),
             transactions::signature.eq(serialize_json(transaction.signature())?),
             transactions::inputs.eq(serialize_json(transaction.inputs())?),
-            transactions::input_refs.eq(serialize_json(transaction.input_refs())?),
             transactions::filled_inputs.eq(serialize_json(transaction.filled_inputs())?),
-            transactions::resulting_outputs.eq(serialize_json(&serde_json::Value::Array(vec![]))?),
+            transactions::resolved_inputs.eq(tx_rec.resolved_inputs().map(serialize_json).transpose()?),
+            transactions::resulting_outputs.eq(serialize_json(tx_rec.resulting_outputs())?),
+            transactions::result.eq(tx_rec.result().map(serialize_json).transpose()?),
+            transactions::execution_time_ms.eq(tx_rec
+                .execution_time()
+                .map(|d| i64::try_from(d.as_millis()).unwrap_or(i64::MAX))),
+            transactions::final_decision.eq(tx_rec.final_decision().map(|d| d.to_string())),
+            transactions::finalized_at.eq(tx_rec
+                .finalized_time()
+                .map(|t| {
+                    let now = OffsetDateTime::now_utc().saturating_sub(t.try_into()?);
+                    Ok(PrimitiveDateTime::new(now.date(), now.time()))
+                })
+                .transpose()
+                .map_err(|e: time::error::ConversionRange| StorageError::QueryError {
+                    reason: format!("Cannot convert finalize time into PrimitiveDateTime: {e}"),
+                })?),
+            transactions::abort_details.eq(tx_rec.abort_details()),
+            transactions::min_epoch.eq(transaction.min_epoch().map(|e| e.as_u64() as i64)),
+            transactions::max_epoch.eq(transaction.max_epoch().map(|e| e.as_u64() as i64)),
         );
 
         diesel::insert_into(transactions::table)
@@ -589,30 +608,31 @@ impl<'tx, TAddr: NodeAddressable + 'tx> StateStoreWriteTransaction for SqliteSta
         #[derive(AsChangeset)]
         #[diesel(table_name = transactions)]
         struct Changes {
-            result: Option<Option<String>>,
-            filled_inputs: Option<String>,
-            resulting_outputs: Option<String>,
-            execution_time_ms: Option<Option<i64>>,
-            final_decision: Option<Option<String>>,
-            finalized_at: Option<Option<PrimitiveDateTime>>,
-            abort_details: Option<Option<String>>,
+            result: Option<String>,
+            filled_inputs: String,
+            resulting_outputs: String,
+            resolved_inputs: Option<String>,
+            execution_time_ms: Option<i64>,
+            final_decision: Option<String>,
+            finalized_at: Option<PrimitiveDateTime>,
+            abort_details: Option<String>,
         }
 
         let change_set = Changes {
-            result: Some(transaction_rec.result().map(serialize_json).transpose()?),
-            filled_inputs: Some(serialize_json(transaction.filled_inputs())?),
-            resulting_outputs: Some(serialize_json(transaction_rec.resulting_outputs())?),
-            execution_time_ms: Some(
-                transaction_rec
-                    .execution_time()
-                    .map(|d| i64::try_from(d.as_millis()).unwrap_or(i64::MAX)),
-            ),
-            final_decision: Some(transaction_rec.final_decision().map(|d| d.to_string())),
-            finalized_at: Some(transaction_rec.final_decision().map(|_| {
+            result: transaction_rec.result().map(serialize_json).transpose()?,
+            filled_inputs: serialize_json(transaction.filled_inputs())?,
+            resulting_outputs: serialize_json(transaction_rec.resulting_outputs())?,
+            resolved_inputs: transaction_rec.resolved_inputs().map(serialize_json).transpose()?,
+            execution_time_ms: transaction_rec
+                .execution_time()
+                .map(|d| i64::try_from(d.as_millis()).unwrap_or(i64::MAX)),
+
+            final_decision: transaction_rec.final_decision().map(|d| d.to_string()),
+            finalized_at: transaction_rec.final_decision().map(|_| {
                 let now = OffsetDateTime::now_utc();
                 PrimitiveDateTime::new(now.date(), now.time())
-            })),
-            abort_details: Some(transaction_rec.abort_details.clone()),
+            }),
+            abort_details: transaction_rec.abort_details.clone(),
         };
 
         let num_affected = diesel::update(transactions::table)
@@ -650,7 +670,7 @@ impl<'tx, TAddr: NodeAddressable + 'tx> StateStoreWriteTransaction for SqliteSta
                     transactions::instructions.eq(serialize_json(transaction.instructions())?),
                     transactions::signature.eq(serialize_json(transaction.signature())?),
                     transactions::inputs.eq(serialize_json(transaction.inputs())?),
-                    transactions::input_refs.eq(serialize_json(transaction.input_refs())?),
+                    transactions::resolved_inputs.eq(rec.resolved_inputs().map(serialize_json).transpose()?),
                     transactions::filled_inputs.eq(serialize_json(transaction.filled_inputs())?),
                     transactions::resulting_outputs.eq(serialize_json(rec.resulting_outputs())?),
                     transactions::result.eq(rec.result().map(serialize_json).transpose()?),
@@ -700,6 +720,40 @@ impl<'tx, TAddr: NodeAddressable + 'tx> StateStoreWriteTransaction for SqliteSta
         Ok(())
     }
 
+    fn transaction_pool_set_atom(&mut self, transaction: TransactionAtom) -> Result<(), StorageError> {
+        use crate::schema::transaction_pool;
+
+        let transaction_id = serialize_hex(transaction.id);
+
+        let change_set = (
+            transaction_pool::original_decision.eq(transaction.decision.to_string()),
+            transaction_pool::transaction_fee.eq(transaction.transaction_fee as i64),
+            transaction_pool::evidence.eq(serialize_json(&transaction.evidence)?),
+            transaction_pool::leader_fee.eq(transaction.leader_fee.as_ref().map(|f| f.fee as i64)),
+            transaction_pool::global_exhaust_burn
+                .eq(transaction.leader_fee.as_ref().map(|f| f.global_exhaust_burn as i64)),
+            transaction_pool::updated_at.eq(now()),
+        );
+
+        let num_affected = diesel::update(transaction_pool::table)
+            .filter(transaction_pool::transaction_id.eq(&transaction_id))
+            .set(change_set)
+            .execute(self.connection())
+            .map_err(|e| SqliteStorageError::DieselError {
+                operation: "transaction_pool_set_atom",
+                source: e,
+            })?;
+
+        if num_affected == 0 {
+            return Err(StorageError::NotFound {
+                item: "transaction".to_string(),
+                key: transaction.id.to_string(),
+            });
+        }
+
+        Ok(())
+    }
+
     fn transaction_pool_add_pending_update(&mut self, update: TransactionPoolStatusUpdate) -> Result<(), StorageError> {
         use crate::schema::{transaction_pool, transaction_pool_state_updates};
 
@@ -918,20 +972,13 @@ impl<'tx, TAddr: NodeAddressable + 'tx> StateStoreWriteTransaction for SqliteSta
     ) -> Result<(), StorageError> {
         use crate::schema::missing_transactions;
 
-        let missing_transaction_ids = missing_transaction_ids
-            .into_iter()
-            .map(serialize_hex)
-            .collect::<Vec<_>>();
-        let awaiting_transaction_ids = awaiting_transaction_ids
-            .into_iter()
-            .map(serialize_hex)
-            .collect::<Vec<_>>();
+        let missing_transaction_ids = missing_transaction_ids.into_iter().map(serialize_hex);
+        let awaiting_transaction_ids = awaiting_transaction_ids.into_iter().map(serialize_hex);
         let block_id_hex = serialize_hex(block.id());
 
         self.parked_blocks_insert(block)?;
 
         let values = missing_transaction_ids
-            .iter()
             .map(|tx_id| {
                 (
                     missing_transactions::block_id.eq(&block_id_hex),
@@ -940,7 +987,7 @@ impl<'tx, TAddr: NodeAddressable + 'tx> StateStoreWriteTransaction for SqliteSta
                     missing_transactions::is_awaiting_execution.eq(false),
                 )
             })
-            .chain(awaiting_transaction_ids.iter().map(|tx_id| {
+            .chain(awaiting_transaction_ids.map(|tx_id| {
                 (
                     missing_transactions::block_id.eq(&block_id_hex),
                     missing_transactions::block_height.eq(block.height().as_u64() as i64),
@@ -966,16 +1013,7 @@ impl<'tx, TAddr: NodeAddressable + 'tx> StateStoreWriteTransaction for SqliteSta
         current_height: NodeHeight,
         transaction_id: &TransactionId,
     ) -> Result<Option<Block>, StorageError> {
-        use crate::schema::{missing_transactions, transactions};
-
-        // delete all entries that are for previous heights
-        diesel::delete(missing_transactions::table)
-            .filter(missing_transactions::block_height.lt(current_height.as_u64().saturating_sub(1) as i64))
-            .execute(self.connection())
-            .map_err(|e| SqliteStorageError::DieselError {
-                operation: "missing_transactions_remove",
-                source: e,
-            })?;
+        use crate::schema::missing_transactions;
 
         let transaction_id = serialize_hex(transaction_id);
         let block_id = missing_transactions::table
@@ -999,7 +1037,7 @@ impl<'tx, TAddr: NodeAddressable + 'tx> StateStoreWriteTransaction for SqliteSta
                 operation: "missing_transactions_remove",
                 source: e,
             })?;
-        let mut missing_transactions = missing_transactions::table
+        let missing_transactions = missing_transactions::table
             .select(missing_transactions::transaction_id)
             .filter(missing_transactions::block_id.eq(&block_id))
             .get_results::<String>(self.connection())
@@ -1009,33 +1047,16 @@ impl<'tx, TAddr: NodeAddressable + 'tx> StateStoreWriteTransaction for SqliteSta
             })?;
 
         if missing_transactions.is_empty() {
-            return self.parked_blocks_remove(&block_id).map(Some);
-        }
-
-        // Make double sure that we dont have these transactions due to a race condition between inserting
-        // missing transactions and them completing execution.
-        let found_transaction_ids = transactions::table
-            .select(transactions::transaction_id)
-            .filter(transactions::transaction_id.eq_any(&missing_transactions))
-            .filter(transactions::result.is_not_null())
-            .get_results::<String>(self.connection())
-            .map_err(|e| SqliteStorageError::DieselError {
-                operation: "transactions_get_many",
-                source: e,
-            })?;
-
-        diesel::delete(missing_transactions::table)
-            .filter(missing_transactions::transaction_id.eq_any(&found_transaction_ids))
-            .execute(self.connection())
-            .map_err(|e| SqliteStorageError::DieselError {
-                operation: "missing_transactions_remove",
-                source: e,
-            })?;
-
-        missing_transactions.retain(|id| found_transaction_ids.iter().all(|found| found != id));
-
-        if missing_transactions.is_empty() {
-            return self.parked_blocks_remove(&block_id).map(Some);
+            // delete all entries that are for previous heights
+            diesel::delete(missing_transactions::table)
+                .filter(missing_transactions::block_height.lt(current_height.as_u64() as i64))
+                .execute(self.connection())
+                .map_err(|e| SqliteStorageError::DieselError {
+                    operation: "missing_transactions_remove",
+                    source: e,
+                })?;
+            let block = self.parked_blocks_remove(&block_id)?;
+            return Ok(Some(block));
         }
 
         Ok(None)
@@ -1064,7 +1085,7 @@ impl<'tx, TAddr: NodeAddressable + 'tx> StateStoreWriteTransaction for SqliteSta
         Ok(())
     }
 
-    fn substates_try_lock_many<'a, I: IntoIterator<Item = &'a SubstateAddress>>(
+    fn substates_try_lock_many<'a, B: Borrow<SubstateAddress>, I: IntoIterator<Item = B>>(
         &mut self,
         locked_by_tx: &TransactionId,
         objects: I,
@@ -1073,7 +1094,10 @@ impl<'tx, TAddr: NodeAddressable + 'tx> StateStoreWriteTransaction for SqliteSta
         use crate::schema::substates;
 
         // Lock unique shards
-        let objects: HashSet<String> = objects.into_iter().map(serialize_hex).collect();
+        let objects = objects
+            .into_iter()
+            .map(|v| serialize_hex(v.borrow()))
+            .collect::<HashSet<_>>();
 
         let locked_details = substates::table
             .select((substates::is_locked_w, substates::destroyed_by_transaction))
@@ -1133,7 +1157,7 @@ impl<'tx, TAddr: NodeAddressable + 'tx> StateStoreWriteTransaction for SqliteSta
         Ok(SubstateLockState::LockAcquired)
     }
 
-    fn substates_try_unlock_many<'a, I: IntoIterator<Item = &'a SubstateAddress>>(
+    fn substates_try_unlock_many<B: Borrow<SubstateAddress>, I: IntoIterator<Item = B>>(
         &mut self,
         locked_by_tx: &TransactionId,
         objects: I,
@@ -1141,7 +1165,10 @@ impl<'tx, TAddr: NodeAddressable + 'tx> StateStoreWriteTransaction for SqliteSta
     ) -> Result<(), StorageError> {
         use crate::schema::substates;
 
-        let objects: HashSet<String> = objects.into_iter().map(serialize_hex).collect();
+        let objects = objects
+            .into_iter()
+            .map(|v| serialize_hex(v.borrow()))
+            .collect::<HashSet<_>>();
 
         match lock_flag {
             SubstateLockFlag::Write => {
diff --git a/dan_layer/storage/src/consensus_models/command.rs b/dan_layer/storage/src/consensus_models/command.rs
index da119c3a9..cb502f679 100644
--- a/dan_layer/storage/src/consensus_models/command.rs
+++ b/dan_layer/storage/src/consensus_models/command.rs
@@ -66,7 +66,7 @@ impl Evidence {
         self.evidence.iter_mut()
     }
 
-    pub fn shards_iter(&self) -> impl Iterator<Item = &SubstateAddress> + '_ {
+    pub fn substate_addresses_iter(&self) -> impl Iterator<Item = &SubstateAddress> + '_ {
         self.evidence.keys()
     }
 
@@ -282,10 +282,10 @@ impl Command {
 
     pub fn involved_shards(&self) -> impl Iterator<Item = &SubstateAddress> + '_ {
         match self {
-            Command::Prepare(tx) => tx.evidence.shards_iter(),
-            Command::LocalPrepared(tx) => tx.evidence.shards_iter(),
-            Command::Accept(tx) => tx.evidence.shards_iter(),
-            Command::LocalOnly(tx) => tx.evidence.shards_iter(),
+            Command::Prepare(tx) => tx.evidence.substate_addresses_iter(),
+            Command::LocalPrepared(tx) => tx.evidence.substate_addresses_iter(),
+            Command::Accept(tx) => tx.evidence.substate_addresses_iter(),
+            Command::LocalOnly(tx) => tx.evidence.substate_addresses_iter(),
             Command::ForeignProposal(_) => panic!("ForeignProposal does not have involved shards"),
             Command::EpochEvent(_) => panic!("EpochEvent does not have involved shards"),
         }
diff --git a/dan_layer/storage/src/consensus_models/executed_transaction.rs b/dan_layer/storage/src/consensus_models/executed_transaction.rs
index 7f3a6ab82..c92e1012b 100644
--- a/dan_layer/storage/src/consensus_models/executed_transaction.rs
+++ b/dan_layer/storage/src/consensus_models/executed_transaction.rs
@@ -4,7 +4,6 @@
 use std::{
     collections::{HashMap, HashSet},
     hash::Hash,
-    ops::DerefMut,
     time::Duration,
 };
 
@@ -18,7 +17,7 @@ use tari_engine_types::{
 use tari_transaction::{Transaction, TransactionId, VersionedSubstateId};
 
 use crate::{
-    consensus_models::{Decision, Evidence, ShardEvidence, TransactionAtom, TransactionRecord},
+    consensus_models::{Decision, Evidence, ShardEvidence, SubstateLockFlag, TransactionAtom, TransactionRecord},
     StateStoreReadTransaction,
     StateStoreWriteTransaction,
     StorageError,
@@ -34,6 +33,7 @@ pub struct ExecutedTransaction {
     transaction: Transaction,
     result: ExecuteResult,
     resulting_outputs: Vec<VersionedSubstateId>,
+    resolved_inputs: Option<IndexSet<VersionedSubstateIdLockIntent>>,
     #[cfg_attr(feature = "ts", ts(type = "{secs: number, nanos: number}"))]
     execution_time: Duration,
     final_decision: Option<Decision>,
@@ -51,6 +51,7 @@ impl ExecutedTransaction {
     ) -> Self {
         Self {
             transaction,
+            resolved_inputs: None,
             result,
             execution_time,
             resulting_outputs,
@@ -96,15 +97,22 @@ impl ExecutedTransaction {
         &self.result
     }
 
+    pub fn all_inputs_iter(&self) -> impl Iterator<Item = &VersionedSubstateId> + '_ {
+        self.resolved_inputs
+            .as_ref()
+            .into_iter()
+            .flatten()
+            .map(|input| &input.versioned_substate_id)
+    }
+
     pub fn involved_shards_iter(&self) -> impl Iterator<Item = SubstateAddress> + '_ {
-        self.transaction
-            .all_inputs_iter()
+        self.all_inputs_iter()
             .map(|input| input.to_substate_address())
             .chain(self.resulting_outputs.iter().map(|output| output.to_substate_address()))
     }
 
-    pub fn num_involved_shards(&self) -> usize {
-        self.transaction.num_involved_shards() + self.resulting_outputs.len()
+    pub fn num_inputs_and_outputs(&self) -> usize {
+        self.transaction.num_unique_inputs() + self.resulting_outputs.len()
     }
 
     pub fn into_final_result(self) -> Option<ExecuteResult> {
@@ -141,30 +149,25 @@ impl ExecutedTransaction {
         &self.resulting_outputs
     }
 
+    pub fn resolved_inputs(&self) -> Option<&IndexSet<VersionedSubstateIdLockIntent>> {
+        self.resolved_inputs.as_ref()
+    }
+
+    pub fn set_resolved_inputs(&mut self, resolved_inputs: IndexSet<VersionedSubstateIdLockIntent>) -> &mut Self {
+        self.resolved_inputs = Some(resolved_inputs);
+        self
+    }
+
     pub fn dissolve(self) -> (Transaction, ExecuteResult) {
         (self.transaction, self.result)
     }
 
     pub fn to_initial_evidence(&self) -> Evidence {
         let mut deduped_evidence = HashMap::new();
-        deduped_evidence.extend(self.transaction.inputs().iter().map(|input| {
+        deduped_evidence.extend(self.resolved_inputs.iter().flatten().map(|input| {
             (input.to_substate_address(), ShardEvidence {
                 qc_ids: IndexSet::new(),
-                lock: LockFlag::Write,
-            })
-        }));
-
-        deduped_evidence.extend(self.transaction.input_refs().iter().map(|input_ref| {
-            (input_ref.to_substate_address(), ShardEvidence {
-                qc_ids: IndexSet::new(),
-                lock: LockFlag::Read,
-            })
-        }));
-
-        deduped_evidence.extend(self.transaction.filled_inputs().iter().map(|input_ref| {
-            (input_ref.to_substate_address(), ShardEvidence {
-                qc_ids: IndexSet::new(),
-                lock: LockFlag::Write,
+                lock: input.lock_flag().as_lock_flag(),
             })
         }));
 
@@ -243,20 +246,7 @@ impl ExecutedTransaction {
 
 impl ExecutedTransaction {
     pub fn insert<TTx: StateStoreWriteTransaction>(&self, tx: &mut TTx) -> Result<(), StorageError> {
-        tx.transactions_insert(self.transaction())?;
-        self.update(tx)
-    }
-
-    pub fn upsert<TTx>(&self, tx: &mut TTx) -> Result<(), StorageError>
-    where
-        TTx: StateStoreWriteTransaction + DerefMut,
-        TTx::Target: StateStoreReadTransaction,
-    {
-        if TransactionRecord::exists(tx.deref_mut(), self.transaction.id())? {
-            self.update(tx)
-        } else {
-            self.insert(tx)
-        }
+        TransactionRecord::from(self.clone()).insert(tx)
     }
 
     pub fn update<TTx: StateStoreWriteTransaction>(&self, tx: &mut TTx) -> Result<(), StorageError> {
@@ -344,6 +334,7 @@ impl TryFrom<TransactionRecord> for ExecutedTransaction {
             transaction: value.transaction,
             result: value.result.unwrap(),
             execution_time: value.execution_time.unwrap_or_default(),
+            resolved_inputs: value.resolved_inputs,
             final_decision: value.final_decision,
             finalized_time: value.finalized_time,
             resulting_outputs: value.resulting_outputs,
@@ -365,3 +356,35 @@ impl Hash for ExecutedTransaction {
         self.transaction.id().hash(state);
     }
 }
+
+#[derive(Debug, Clone, Serialize, Deserialize, Hash, PartialEq, Eq)]
+#[cfg_attr(
+    feature = "ts",
+    derive(ts_rs::TS),
+    ts(export, export_to = "../../bindings/src/types/")
+)]
+pub struct VersionedSubstateIdLockIntent {
+    versioned_substate_id: VersionedSubstateId,
+    lock_flag: SubstateLockFlag,
+}
+
+impl VersionedSubstateIdLockIntent {
+    pub fn new(versioned_substate_id: VersionedSubstateId, lock: SubstateLockFlag) -> Self {
+        Self {
+            versioned_substate_id,
+            lock_flag: lock,
+        }
+    }
+
+    pub fn to_substate_address(&self) -> SubstateAddress {
+        self.versioned_substate_id.to_substate_address()
+    }
+
+    pub fn versioned_substate_id(&self) -> &VersionedSubstateId {
+        &self.versioned_substate_id
+    }
+
+    pub fn lock_flag(&self) -> SubstateLockFlag {
+        self.lock_flag
+    }
+}
diff --git a/dan_layer/storage/src/consensus_models/substate.rs b/dan_layer/storage/src/consensus_models/substate.rs
index bf397613c..9283d9c0b 100644
--- a/dan_layer/storage/src/consensus_models/substate.rs
+++ b/dan_layer/storage/src/consensus_models/substate.rs
@@ -12,13 +12,14 @@ use log::*;
 use serde::{Deserialize, Serialize};
 use tari_common_types::types::FixedHash;
 use tari_dan_common_types::{optional::Optional, Epoch, NodeHeight, SubstateAddress};
-use tari_engine_types::substate::{Substate, SubstateId, SubstateValue};
+use tari_engine_types::{
+    lock::LockFlag,
+    substate::{Substate, SubstateId, SubstateValue},
+};
 use tari_transaction::{TransactionId, VersionedSubstateId};
-#[cfg(feature = "ts")]
-use ts_rs::TS;
 
 use crate::{
-    consensus_models::{Block, BlockId, QcId, QuorumCertificate},
+    consensus_models::{Block, BlockId, QcId, QuorumCertificate, VersionedSubstateIdLockIntent},
     StateStoreReadTransaction,
     StateStoreWriteTransaction,
     StorageError,
@@ -27,7 +28,11 @@ use crate::{
 const LOG_TARGET: &str = "tari::dan::storage::consensus_models::substate";
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
-#[cfg_attr(feature = "ts", derive(TS), ts(export, export_to = "../../bindings/src/types/"))]
+#[cfg_attr(
+    feature = "ts",
+    derive(ts_rs::TS),
+    ts(export, export_to = "../../bindings/src/types/")
+)]
 pub struct SubstateRecord {
     pub substate_id: SubstateId,
     pub version: u32,
@@ -46,7 +51,11 @@ pub struct SubstateRecord {
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
-#[cfg_attr(feature = "ts", derive(TS), ts(export, export_to = "../../bindings/src/types/"))]
+#[cfg_attr(
+    feature = "ts",
+    derive(ts_rs::TS),
+    ts(export, export_to = "../../bindings/src/types/")
+)]
 pub struct SubstateDestroyed {
     #[cfg_attr(feature = "ts", ts(type = "string"))]
     pub by_transaction: TransactionId,
@@ -136,7 +145,7 @@ impl SubstateRecord {
 }
 
 impl SubstateRecord {
-    pub fn try_lock_all<'a, TTx: StateStoreWriteTransaction, I: IntoIterator<Item = &'a SubstateAddress>>(
+    pub fn try_lock_all<TTx: StateStoreWriteTransaction, B: Borrow<SubstateAddress>, I: IntoIterator<Item = B>>(
         tx: &mut TTx,
         locked_by_tx: &TransactionId,
         inputs: I,
@@ -145,7 +154,28 @@ impl SubstateRecord {
         tx.substates_try_lock_many(locked_by_tx, inputs, lock_flag)
     }
 
-    pub fn check_lock_all<'a, TTx: StateStoreReadTransaction, I: IntoIterator<Item = &'a SubstateAddress>>(
+    pub fn try_lock_all2<
+        'a,
+        TTx: StateStoreWriteTransaction,
+        I: IntoIterator<Item = &'a VersionedSubstateIdLockIntent>,
+    >(
+        tx: &mut TTx,
+        locked_by_tx: &TransactionId,
+        inputs: I,
+    ) -> Result<SubstateLockState, StorageError> {
+        // TODO
+        for input in inputs {
+            tx.substates_try_lock_many(
+                locked_by_tx,
+                iter::once(&input.to_substate_address()),
+                input.lock_flag(),
+            )?;
+        }
+
+        Ok(SubstateLockState::LockAcquired)
+    }
+
+    pub fn check_lock_all<TTx: StateStoreReadTransaction, B: Borrow<SubstateAddress>, I: IntoIterator<Item = B>>(
         tx: &mut TTx,
         inputs: I,
         lock_flag: SubstateLockFlag,
@@ -153,7 +183,7 @@ impl SubstateRecord {
         tx.substates_check_lock_many(inputs, lock_flag)
     }
 
-    pub fn try_unlock_many<'a, TTx: StateStoreWriteTransaction, I: IntoIterator<Item = &'a SubstateAddress>>(
+    pub fn try_unlock_many<TTx: StateStoreWriteTransaction, B: Borrow<SubstateAddress>, I: IntoIterator<Item = B>>(
         tx: &mut TTx,
         locked_by_tx: &TransactionId,
         inputs: I,
@@ -402,13 +432,35 @@ impl From<SubstateCreatedProof> for SubstateUpdate {
 }
 
 /// Substate lock flags
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
 #[repr(u8)]
+#[cfg_attr(
+    feature = "ts",
+    derive(ts_rs::TS),
+    ts(export, export_to = "../../bindings/src/types/")
+)]
 pub enum SubstateLockFlag {
     Read = 0x01,
     Write = 0x02,
 }
 
+impl SubstateLockFlag {
+    pub fn is_write(&self) -> bool {
+        matches!(self, Self::Write)
+    }
+
+    pub fn is_read(&self) -> bool {
+        matches!(self, Self::Read)
+    }
+
+    pub fn as_lock_flag(&self) -> LockFlag {
+        match self {
+            Self::Read => LockFlag::Read,
+            Self::Write => LockFlag::Write,
+        }
+    }
+}
+
 #[derive(Debug, Clone, Copy)]
 pub enum SubstateLockState {
     /// The lock was successfully acquired
diff --git a/dan_layer/storage/src/consensus_models/transaction.rs b/dan_layer/storage/src/consensus_models/transaction.rs
index e86f54e3d..a4e0c1071 100644
--- a/dan_layer/storage/src/consensus_models/transaction.rs
+++ b/dan_layer/storage/src/consensus_models/transaction.rs
@@ -7,25 +7,37 @@ use std::{
     time::Duration,
 };
 
-use serde::{Deserialize, Serialize};
+use indexmap::IndexSet;
+use serde::Deserialize;
 use tari_dan_common_types::SubstateAddress;
-use tari_engine_types::commit_result::{ExecuteResult, FinalizeResult, RejectReason};
+use tari_engine_types::{
+    commit_result::{ExecuteResult, FinalizeResult, RejectReason},
+    lock::LockFlag,
+};
 use tari_transaction::{Transaction, TransactionId, VersionedSubstateId};
 
 use crate::{
-    consensus_models::{Decision, ExecutedTransaction},
+    consensus_models::{
+        Decision,
+        Evidence,
+        ExecutedTransaction,
+        ShardEvidence,
+        TransactionAtom,
+        VersionedSubstateIdLockIntent,
+    },
     Ordering,
     StateStoreReadTransaction,
     StateStoreWriteTransaction,
     StorageError,
 };
 
-#[derive(Debug, Clone, Serialize, Deserialize)]
+#[derive(Debug, Clone, Deserialize)]
 pub struct TransactionRecord {
     pub transaction: Transaction,
     pub result: Option<ExecuteResult>,
     pub execution_time: Option<Duration>,
     pub resulting_outputs: Vec<VersionedSubstateId>,
+    pub resolved_inputs: Option<IndexSet<VersionedSubstateIdLockIntent>>,
     pub final_decision: Option<Decision>,
     pub finalized_time: Option<Duration>,
     pub abort_details: Option<String>,
@@ -36,6 +48,7 @@ impl TransactionRecord {
         Self {
             transaction,
             result: None,
+            resolved_inputs: None,
             execution_time: None,
             final_decision: None,
             finalized_time: None,
@@ -47,6 +60,7 @@ impl TransactionRecord {
     pub fn load(
         transaction: Transaction,
         result: Option<ExecuteResult>,
+        resolved_inputs: Option<IndexSet<VersionedSubstateIdLockIntent>>,
         execution_time: Option<Duration>,
         final_decision: Option<Decision>,
         finalized_time: Option<Duration>,
@@ -55,6 +69,7 @@ impl TransactionRecord {
     ) -> Self {
         Self {
             transaction,
+            resolved_inputs,
             result,
             execution_time,
             final_decision,
@@ -84,17 +99,18 @@ impl TransactionRecord {
         self.result.as_ref()
     }
 
-    pub fn involved_shards_iter(&self) -> impl Iterator<Item = SubstateAddress> + '_ {
-        self.transaction
-            .all_inputs_iter()
-            .map(|requirement| requirement.to_substate_address())
-            .chain(self.resulting_outputs.iter().map(|output| output.to_substate_address()))
+    pub fn has_executed(&self) -> bool {
+        self.result.is_some()
     }
 
     pub fn resulting_outputs(&self) -> &[VersionedSubstateId] {
         &self.resulting_outputs
     }
 
+    pub fn resolved_inputs(&self) -> Option<&IndexSet<VersionedSubstateIdLockIntent>> {
+        self.resolved_inputs.as_ref()
+    }
+
     pub fn final_decision(&self) -> Option<Decision> {
         self.final_decision
     }
@@ -146,7 +162,7 @@ impl TransactionRecord {
 
 impl TransactionRecord {
     pub fn insert<TTx: StateStoreWriteTransaction>(&self, tx: &mut TTx) -> Result<(), StorageError> {
-        tx.transactions_insert(&self.transaction)
+        tx.transactions_insert(self)
     }
 
     pub fn save<TTx>(&self, tx: &mut TTx) -> Result<(), StorageError>
@@ -173,6 +189,18 @@ impl TransactionRecord {
         tx.transactions_update(self)
     }
 
+    pub fn upsert<TTx>(&self, tx: &mut TTx) -> Result<(), StorageError>
+    where
+        TTx: StateStoreWriteTransaction + DerefMut,
+        TTx::Target: StateStoreReadTransaction,
+    {
+        if TransactionRecord::exists(tx.deref_mut(), self.id())? {
+            self.update(tx)
+        } else {
+            self.insert(tx)
+        }
+    }
+
     pub fn get<TTx: StateStoreReadTransaction>(tx: &mut TTx, tx_id: &TransactionId) -> Result<Self, StorageError> {
         tx.transactions_get(tx_id)
     }
@@ -219,25 +247,64 @@ impl TransactionRecord {
         tx.transactions_get_paginated(limit, offset, ordering)
     }
 
-    pub fn get_involved_shards<'a, TTx: StateStoreReadTransaction, I: IntoIterator<Item = &'a TransactionId>>(
-        tx: &mut TTx,
-        transactions: I,
-    ) -> Result<HashMap<TransactionId, HashSet<SubstateAddress>>, StorageError> {
-        let (transactions, missing) = Self::get_any(tx, transactions)?;
-        if !missing.is_empty() {
-            return Err(StorageError::NotFound {
-                item: "ExecutedTransactions".to_string(),
-                key: missing
-                    .into_iter()
-                    .map(|id| id.to_string())
-                    .collect::<Vec<_>>()
-                    .join(", "),
-            });
+    pub fn to_atom(&self) -> TransactionAtom {
+        if let Some(result) = self.result() {
+            let decision = if result.finalize.result.is_accept() {
+                Decision::Commit
+            } else {
+                Decision::Abort
+            };
+
+            TransactionAtom {
+                id: *self.id(),
+                decision,
+                evidence: self.to_initial_evidence(),
+                transaction_fee: result
+                    .finalize
+                    .fee_receipt
+                    .total_fees_paid()
+                    .as_u64_checked()
+                    .unwrap_or(0),
+                // We calculate the leader fee later depending on the epoch of the block
+                leader_fee: None,
+            }
+        } else {
+            // Deferred
+            TransactionAtom {
+                id: *self.transaction.id(),
+                decision: Decision::Deferred,
+                evidence: Default::default(),
+                transaction_fee: 0,
+                leader_fee: None,
+            }
         }
-        Ok(transactions
-            .into_iter()
-            .map(|t| (*t.transaction.id(), t.involved_shards_iter().collect()))
-            .collect())
+    }
+
+    fn to_initial_evidence(&self) -> Evidence {
+        let mut deduped_evidence = HashMap::new();
+        deduped_evidence.extend(self.resolved_inputs.iter().flatten().map(|input| {
+            (input.to_substate_address(), ShardEvidence {
+                qc_ids: IndexSet::new(),
+                lock: input.lock_flag().as_lock_flag(),
+            })
+        }));
+
+        let tx_reciept_address = SubstateAddress::for_transaction_receipt(self.id().into_receipt_address());
+        deduped_evidence.extend(
+            self.resulting_outputs
+                    .iter()
+                    .map(|output| output.to_substate_address())
+                    // Exclude transaction receipt address from evidence since all involved shards will commit it
+                    .filter(|output| *output != tx_reciept_address)
+                    .map(|output| {
+                        (output, ShardEvidence {
+                            qc_ids: IndexSet::new(),
+                            lock: LockFlag::Write,
+                        })
+                    }),
+        );
+
+        deduped_evidence.into_iter().collect()
     }
 }
 
@@ -248,12 +315,14 @@ impl From<ExecutedTransaction> for TransactionRecord {
         let finalized_time = tx.finalized_time();
         let abort_details = tx.abort_details().cloned();
         let resulting_outputs = tx.resulting_outputs().to_vec();
+        let resolved_inputs = tx.resolved_inputs().cloned();
         let (transaction, result) = tx.dissolve();
 
         Self {
             transaction,
             result: Some(result),
             execution_time: Some(execution_time),
+            resolved_inputs,
             final_decision,
             finalized_time,
             resulting_outputs,
diff --git a/dan_layer/storage/src/consensus_models/transaction_decision.rs b/dan_layer/storage/src/consensus_models/transaction_decision.rs
index 805e4a9f7..dab8d3d61 100644
--- a/dan_layer/storage/src/consensus_models/transaction_decision.rs
+++ b/dan_layer/storage/src/consensus_models/transaction_decision.rs
@@ -18,6 +18,8 @@ pub enum Decision {
     Commit,
     /// Decision to ABORT the transaction
     Abort,
+    /// Decision has not yet been reached
+    Deferred,
 }
 
 impl Decision {
@@ -29,10 +31,15 @@ impl Decision {
         matches!(self, Decision::Abort)
     }
 
+    pub fn is_deferred(&self) -> bool {
+        matches!(self, Decision::Deferred)
+    }
+
     pub fn and(self, other: Self) -> Self {
         match self {
             Decision::Commit => other,
             Decision::Abort => Decision::Abort,
+            Decision::Deferred => Decision::Deferred,
         }
     }
 
@@ -40,6 +47,7 @@ impl Decision {
         match self {
             Decision::Commit => "Commit",
             Decision::Abort => "Abort",
+            Decision::Deferred => "Deferred",
         }
     }
 }
@@ -57,6 +65,7 @@ impl FromStr for Decision {
         match s {
             "Commit" => Ok(Decision::Commit),
             "Abort" => Ok(Decision::Abort),
+            "Deferred" => Ok(Decision::Deferred),
             _ => Err(()),
         }
     }
diff --git a/dan_layer/storage/src/consensus_models/transaction_pool.rs b/dan_layer/storage/src/consensus_models/transaction_pool.rs
index 85fe30fc2..34ac9e887 100644
--- a/dan_layer/storage/src/consensus_models/transaction_pool.rs
+++ b/dan_layer/storage/src/consensus_models/transaction_pool.rs
@@ -32,7 +32,7 @@ use crate::{
     StorageError,
 };
 
-const _LOG_TARGET: &str = "tari::dan::storage::transaction_pool";
+const LOG_TARGET: &str = "tari::dan::storage::transaction_pool";
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize)]
 #[cfg_attr(
@@ -139,7 +139,7 @@ impl<TStateStore: StateStore> TransactionPool<TStateStore> {
         // let leaf = LeafBlock::get(tx)?;
         let locked = LockedBlock::get(tx)?;
         debug!(
-            target: _LOG_TARGET,
+            target: LOG_TARGET,
             "TransactionPool::get: transaction_id {}, leaf block {} and locked block {}",
             id,
             leaf,
@@ -167,6 +167,15 @@ impl<TStateStore: StateStore> TransactionPool<TStateStore> {
         Ok(())
     }
 
+    pub fn set_atom(
+        &self,
+        tx: &mut TStateStore::WriteTransaction<'_>,
+        transaction: TransactionAtom,
+    ) -> Result<(), TransactionPoolError> {
+        tx.transaction_pool_set_atom(transaction)?;
+        Ok(())
+    }
+
     pub fn get_batch_for_next_block(
         &self,
         tx: &mut TStateStore::ReadTransaction<'_>,
@@ -274,6 +283,10 @@ impl TransactionPoolRecord {
             .unwrap_or(self.original_decision())
     }
 
+    pub fn is_deferred(&self) -> bool {
+        self.original_decision().is_deferred()
+    }
+
     pub fn current_local_decision(&self) -> Decision {
         self.local_decision().unwrap_or(self.original_decision())
     }
@@ -366,13 +379,7 @@ impl TransactionPoolRecord {
 
     pub fn set_remote_decision(&mut self, decision: Decision) -> &mut Self {
         // Only set remote_decision to ABORT, or COMMIT if it is not already ABORT
-        self.remote_decision = self
-            .remote_decision()
-            .map(|d| match d {
-                Decision::Commit => decision,
-                Decision::Abort => Decision::Abort,
-            })
-            .or(Some(decision));
+        self.remote_decision = self.remote_decision().map(|d| d.and(decision)).or(Some(decision));
         self
     }
 
@@ -383,8 +390,8 @@ impl TransactionPoolRecord {
 
     pub fn add_evidence(&mut self, committee_shard: &CommitteeShard, qc_id: QcId) -> &mut Self {
         let evidence = &mut self.transaction.evidence;
-        for (shard, evidence_mut) in evidence.iter_mut() {
-            if committee_shard.includes_substate_address(shard) {
+        for (address, evidence_mut) in evidence.iter_mut() {
+            if committee_shard.includes_substate_address(address) {
                 evidence_mut.qc_ids.insert(qc_id);
             }
         }
diff --git a/dan_layer/storage/src/state_store/mod.rs b/dan_layer/storage/src/state_store/mod.rs
index d10d0489e..abcfc5152 100644
--- a/dan_layer/storage/src/state_store/mod.rs
+++ b/dan_layer/storage/src/state_store/mod.rs
@@ -11,7 +11,7 @@ use serde::{Deserialize, Serialize};
 use tari_common_types::types::{FixedHash, PublicKey};
 use tari_dan_common_types::{Epoch, NodeAddressable, NodeHeight, SubstateAddress};
 use tari_state_tree::{TreeStore, TreeStoreReader, Version};
-use tari_transaction::{Transaction, TransactionId, VersionedSubstateId};
+use tari_transaction::{TransactionId, VersionedSubstateId};
 #[cfg(feature = "ts")]
 use ts_rs::TS;
 
@@ -236,7 +236,7 @@ pub trait StateStoreReadTransaction {
         &mut self,
         transaction_id: &TransactionId,
     ) -> Result<Vec<SubstateRecord>, StorageError>;
-    fn substates_check_lock_many<'a, I: IntoIterator<Item = &'a SubstateAddress>>(
+    fn substates_check_lock_many<B: Borrow<SubstateAddress>, I: IntoIterator<Item = B>>(
         &mut self,
         objects: I,
         lock_flag: SubstateLockFlag,
@@ -295,7 +295,7 @@ pub trait StateStoreWriteTransaction {
     ) -> Result<(), StorageError>;
 
     // -------------------------------- Transaction -------------------------------- //
-    fn transactions_insert(&mut self, transaction: &Transaction) -> Result<(), StorageError>;
+    fn transactions_insert(&mut self, transaction: &TransactionRecord) -> Result<(), StorageError>;
     fn transactions_update(&mut self, transaction: &TransactionRecord) -> Result<(), StorageError>;
     fn transactions_save_all<'a, I: IntoIterator<Item = &'a TransactionRecord>>(
         &mut self,
@@ -308,6 +308,7 @@ pub trait StateStoreWriteTransaction {
         stage: TransactionPoolStage,
         is_ready: bool,
     ) -> Result<(), StorageError>;
+    fn transaction_pool_set_atom(&mut self, transaction: TransactionAtom) -> Result<(), StorageError>;
     fn transaction_pool_add_pending_update(
         &mut self,
         pool_update: TransactionPoolStatusUpdate,
@@ -349,14 +350,14 @@ pub trait StateStoreWriteTransaction {
     fn votes_insert(&mut self, vote: &Vote) -> Result<(), StorageError>;
 
     //---------------------------------- Substates --------------------------------------------//
-    fn substates_try_lock_many<'a, I: IntoIterator<Item = &'a SubstateAddress>>(
+    fn substates_try_lock_many<B: Borrow<SubstateAddress>, I: IntoIterator<Item = B>>(
         &mut self,
         locked_by_tx: &TransactionId,
         objects: I,
         lock_flag: SubstateLockFlag,
     ) -> Result<SubstateLockState, StorageError>;
 
-    fn substates_try_unlock_many<'a, I: IntoIterator<Item = &'a SubstateAddress>>(
+    fn substates_try_unlock_many<B: Borrow<SubstateAddress>, I: IntoIterator<Item = B>>(
         &mut self,
         locked_by_tx: &TransactionId,
         objects: I,
diff --git a/dan_layer/template_test_tooling/src/template_test.rs b/dan_layer/template_test_tooling/src/template_test.rs
index bd6133bf2..e0ab4d092 100644
--- a/dan_layer/template_test_tooling/src/template_test.rs
+++ b/dan_layer/template_test_tooling/src/template_test.rs
@@ -53,7 +53,7 @@ use tari_template_lib::{
     prelude::{ComponentAccessRules, CONFIDENTIAL_TARI_RESOURCE_ADDRESS},
     Hash,
 };
-use tari_transaction::{SubstateRequirement, Transaction};
+use tari_transaction::{Transaction, VersionedSubstateId};
 use tari_transaction_manifest::{parse_manifest, ManifestValue};
 
 use crate::{read_only_state_store::ReadOnlyStateStore, track_calls::TrackCallsModule, Package};
@@ -476,8 +476,8 @@ impl TemplateTest {
             transaction.filled_inputs_mut().extend(
                 access
                     .iter_raw()
-                    .map(|(k, _)| SubstateId::from_bytes(k).unwrap())
-                    .map(|s| SubstateRequirement::new(s, None)),
+                    .map(|(k, s)| (SubstateId::from_bytes(k).unwrap(), Substate::from_bytes(s).unwrap()))
+                    .map(|(id, s)| VersionedSubstateId::new(id, s.version())),
             );
         }
 
diff --git a/dan_layer/transaction/Cargo.toml b/dan_layer/transaction/Cargo.toml
index fb00dd174..cbe1354ec 100644
--- a/dan_layer/transaction/Cargo.toml
+++ b/dan_layer/transaction/Cargo.toml
@@ -15,6 +15,7 @@ tari_crypto = { workspace = true, features = ["borsh"] }
 tari_template_lib = { workspace = true }
 
 rand = { workspace = true }
+indexmap = { workspace = true, features = ["serde"] }
 serde = { workspace = true, default-features = true }
 thiserror = { workspace = true }
 ts-rs = { workspace = true, optional = true }
diff --git a/dan_layer/transaction/src/builder.rs b/dan_layer/transaction/src/builder.rs
index ea00c9403..09bfa760f 100644
--- a/dan_layer/transaction/src/builder.rs
+++ b/dan_layer/transaction/src/builder.rs
@@ -1,16 +1,9 @@
 //   Copyright 2023 The Tari Project
 //   SPDX-License-Identifier: BSD-3-Clause
 
-use std::borrow::Borrow;
-
 use tari_common_types::types::{PrivateKey, PublicKey};
 use tari_dan_common_types::Epoch;
-use tari_engine_types::{
-    confidential::ConfidentialClaim,
-    instruction::Instruction,
-    substate::SubstateId,
-    TemplateAddress,
-};
+use tari_engine_types::{confidential::ConfidentialClaim, instruction::Instruction, TemplateAddress};
 use tari_template_lib::{
     args,
     args::Arg,
@@ -166,25 +159,14 @@ impl TransactionBuilder {
         self
     }
 
-    /// Add an input to be consumed
-    pub fn add_input(mut self, input_object: SubstateRequirement) -> Self {
-        self.unsigned_transaction.inputs.push(input_object);
+    /// Add an input to use in the transaction
+    pub fn add_input<I: Into<SubstateRequirement>>(mut self, input_object: I) -> Self {
+        self.unsigned_transaction.inputs.insert(input_object.into());
         // Reset the signature as it is no longer valid
         self.signature = None;
         self
     }
 
-    pub fn with_substate_inputs<I: IntoIterator<Item = (B, Option<u32>)>, B: Borrow<SubstateId>>(
-        self,
-        inputs: I,
-    ) -> Self {
-        self.with_inputs(
-            inputs
-                .into_iter()
-                .map(|(a, v)| SubstateRequirement::new(a.borrow().clone(), v)),
-        )
-    }
-
     pub fn with_inputs<I: IntoIterator<Item = SubstateRequirement>>(mut self, inputs: I) -> Self {
         self.unsigned_transaction.inputs.extend(inputs);
         // Reset the signature as it is no longer valid
@@ -192,32 +174,6 @@ impl TransactionBuilder {
         self
     }
 
-    /// Add an input to be used without mutation
-    pub fn add_input_ref(mut self, input_object: SubstateRequirement) -> Self {
-        self.unsigned_transaction.input_refs.push(input_object);
-        // Reset the signature as it is no longer valid
-        self.signature = None;
-        self
-    }
-
-    pub fn with_substate_input_refs<I: IntoIterator<Item = (B, Option<u32>)>, B: Borrow<SubstateId>>(
-        self,
-        inputs: I,
-    ) -> Self {
-        self.with_input_refs(
-            inputs
-                .into_iter()
-                .map(|(a, v)| SubstateRequirement::new(a.borrow().clone(), v)),
-        )
-    }
-
-    pub fn with_input_refs<I: IntoIterator<Item = SubstateRequirement>>(mut self, inputs: I) -> Self {
-        self.unsigned_transaction.input_refs.extend(inputs);
-        // Reset the signature as it is no longer valid
-        self.signature = None;
-        self
-    }
-
     pub fn with_min_epoch(mut self, min_epoch: Option<Epoch>) -> Self {
         self.unsigned_transaction.min_epoch = min_epoch;
         // Reset the signature as it is no longer valid
@@ -241,7 +197,6 @@ impl TransactionBuilder {
             fee_instructions,
             instructions,
             inputs,
-            input_refs,
             filled_inputs,
             min_epoch,
             max_epoch,
@@ -252,7 +207,6 @@ impl TransactionBuilder {
             instructions,
             self.signature.expect("not signed"),
             inputs,
-            input_refs,
             filled_inputs,
             min_epoch,
             max_epoch,
diff --git a/dan_layer/transaction/src/signature.rs b/dan_layer/transaction/src/signature.rs
index f439ecf2e..7c37327ec 100644
--- a/dan_layer/transaction/src/signature.rs
+++ b/dan_layer/transaction/src/signature.rs
@@ -1,6 +1,7 @@
 //   Copyright 2023 The Tari Project
 //   SPDX-License-Identifier: BSD-3-Clause
 
+use indexmap::IndexSet;
 use rand::rngs::OsRng;
 use serde::{Deserialize, Serialize};
 use tari_common_types::types::{PublicKey, Signature};
@@ -67,8 +68,7 @@ impl TransactionSignature {
 struct TransactionSignatureFields<'a> {
     fee_instructions: &'a [Instruction],
     instructions: &'a [Instruction],
-    inputs: &'a [SubstateRequirement],
-    input_refs: &'a [SubstateRequirement],
+    inputs: &'a IndexSet<SubstateRequirement>,
     min_epoch: Option<Epoch>,
     max_epoch: Option<Epoch>,
 }
@@ -79,7 +79,6 @@ impl<'a> From<&'a UnsignedTransaction> for TransactionSignatureFields<'a> {
             fee_instructions: &transaction.fee_instructions,
             instructions: &transaction.instructions,
             inputs: &transaction.inputs,
-            input_refs: &transaction.input_refs,
             min_epoch: transaction.min_epoch,
             max_epoch: transaction.max_epoch,
         }
diff --git a/dan_layer/transaction/src/transaction.rs b/dan_layer/transaction/src/transaction.rs
index e4116e8a1..328b9c106 100644
--- a/dan_layer/transaction/src/transaction.rs
+++ b/dan_layer/transaction/src/transaction.rs
@@ -1,8 +1,9 @@
 //   Copyright 2023 The Tari Project
 //   SPDX-License-Identifier: BSD-3-Clause
 
-use std::{collections::HashSet, fmt::Display, str::FromStr};
+use std::{borrow::Borrow, collections::HashSet, fmt::Display, str::FromStr};
 
+use indexmap::IndexSet;
 use serde::{Deserialize, Serialize};
 use tari_common_types::types::PublicKey;
 use tari_dan_common_types::{shard::Shard, Epoch, SubstateAddress};
@@ -31,12 +32,10 @@ pub struct Transaction {
     signature: TransactionSignature,
 
     // TODO: Ideally we should ensure uniqueness and ordering invariants for each set.
-    /// Input objects that may be downed by this transaction
-    inputs: Vec<SubstateRequirement>,
-    /// Input objects that must exist but cannot be downed by this transaction
-    input_refs: Vec<SubstateRequirement>,
+    /// Input objects that may be downed (write) or referenced (read) by this transaction.
+    inputs: IndexSet<SubstateRequirement>,
     /// Inputs filled by some authority. These are not part of the transaction hash nor the signature
-    filled_inputs: Vec<SubstateRequirement>,
+    filled_inputs: IndexSet<VersionedSubstateId>,
     min_epoch: Option<Epoch>,
     max_epoch: Option<Epoch>,
 }
@@ -50,9 +49,8 @@ impl Transaction {
         fee_instructions: Vec<Instruction>,
         instructions: Vec<Instruction>,
         signature: TransactionSignature,
-        inputs: Vec<SubstateRequirement>,
-        input_refs: Vec<SubstateRequirement>,
-        filled_inputs: Vec<SubstateRequirement>,
+        inputs: IndexSet<SubstateRequirement>,
+        filled_inputs: IndexSet<VersionedSubstateId>,
         min_epoch: Option<Epoch>,
         max_epoch: Option<Epoch>,
     ) -> Self {
@@ -62,7 +60,6 @@ impl Transaction {
             instructions,
             signature,
             inputs,
-            input_refs,
             filled_inputs,
             min_epoch,
             max_epoch,
@@ -77,7 +74,6 @@ impl Transaction {
             .chain(&self.fee_instructions)
             .chain(&self.instructions)
             .chain(&self.inputs)
-            .chain(&self.input_refs)
             .chain(&self.min_epoch)
             .chain(&self.max_epoch)
             .result()
@@ -89,6 +85,11 @@ impl Transaction {
         &self.id
     }
 
+    pub fn check_id(&self) -> bool {
+        let id = self.calculate_hash();
+        id == self.id
+    }
+
     pub fn hash(&self) -> Hash {
         self.id.into_array().into()
     }
@@ -113,28 +114,14 @@ impl Transaction {
         self.all_input_addresses_iter()
     }
 
-    pub fn num_involved_shards(&self) -> usize {
-        self.inputs().len() + self.input_refs().len() + self.filled_inputs().len()
-    }
-
-    pub fn input_refs(&self) -> &[SubstateRequirement] {
-        &self.input_refs
-    }
-
-    pub fn input_address_refs_iter(&self) -> impl Iterator<Item = SubstateAddress> + '_ {
-        self.input_refs
-            .iter()
-            .map(|i: &SubstateRequirement| i.to_substate_address())
-    }
-
-    pub fn inputs(&self) -> &[SubstateRequirement] {
+    pub fn inputs(&self) -> &IndexSet<SubstateRequirement> {
         &self.inputs
     }
 
     fn input_addresses_iter(&self) -> impl Iterator<Item = SubstateAddress> + '_ {
         self.inputs
             .iter()
-            .map(|i: &SubstateRequirement| i.to_substate_address())
+            .filter_map(|i: &SubstateRequirement| i.to_substate_address())
     }
 
     /// Returns (fee instructions, instructions)
@@ -142,30 +129,41 @@ impl Transaction {
         (self.fee_instructions, self.instructions)
     }
 
-    pub fn all_inputs_iter(&self) -> impl Iterator<Item = &SubstateRequirement> + '_ {
+    pub fn all_inputs_iter(&self) -> impl Iterator<Item = SubstateRequirement> + '_ {
+        self.inputs()
+            .iter()
+            // Filled inputs override other inputs as they are likely filled with versions
+            .filter(|i| self.filled_inputs().iter().all(|fi| fi.substate_id() != i.substate_id()))
+            .cloned()
+            .chain(self.filled_inputs().iter().cloned().map(Into::into))
+    }
+
+    pub fn all_inputs_substate_ids_iter(&self) -> impl Iterator<Item = &SubstateId> + '_ {
         self.inputs()
             .iter()
-            .chain(self.input_refs())
-            .chain(self.filled_inputs())
+            // Filled inputs override other inputs as they are likely filled with versions
+            .filter(|i| self.filled_inputs().iter().all(|fi| fi.substate_id() != i.substate_id()))
+            .map(|i| i.substate_id())
+            .chain(self.filled_inputs().iter().map(|fi| fi.substate_id()))
+    }
+
+    pub fn num_unique_inputs(&self) -> usize {
+        self.all_inputs_substate_ids_iter().count()
     }
 
     pub fn all_input_addresses_iter(&self) -> impl Iterator<Item = SubstateAddress> + '_ {
-        self.input_addresses_iter()
-            .chain(self.input_address_refs_iter())
-            .chain(self.filled_input_addresses_iter())
+        self.input_addresses_iter().chain(self.filled_input_addresses_iter())
     }
 
-    pub fn filled_inputs(&self) -> &[SubstateRequirement] {
+    pub fn filled_inputs(&self) -> &IndexSet<VersionedSubstateId> {
         &self.filled_inputs
     }
 
     fn filled_input_addresses_iter(&self) -> impl Iterator<Item = SubstateAddress> + '_ {
-        self.filled_inputs
-            .iter()
-            .map(|i: &SubstateRequirement| i.to_substate_address())
+        self.filled_inputs.iter().map(|i| i.to_substate_address())
     }
 
-    pub fn filled_inputs_mut(&mut self) -> &mut Vec<SubstateRequirement> {
+    pub fn filled_inputs_mut(&mut self) -> &mut IndexSet<VersionedSubstateId> {
         &mut self.filled_inputs
     }
 
@@ -241,7 +239,7 @@ impl Transaction {
     }
 
     pub fn has_inputs_without_version(&self) -> bool {
-        self.all_inputs_iter().any(|i| i.version().is_none())
+        self.inputs().iter().any(|i| i.version().is_none())
     }
 }
 
@@ -280,15 +278,15 @@ impl SubstateRequirement {
         self.version
     }
 
-    pub fn to_substate_address(&self) -> SubstateAddress {
-        // TODO: properly handle the the no-version case
-        SubstateAddress::from_address(self.substate_id(), self.version().unwrap_or_default())
+    pub fn to_substate_address(&self) -> Option<SubstateAddress> {
+        Some(SubstateAddress::from_address(self.substate_id(), self.version()?))
     }
 
     /// Calculates and returns the shard number that this SubstateAddress belongs.
-    /// A shard is an equal division of the 256-bit shard space.
-    pub fn to_committee_shard(&self, num_committees: u32) -> Shard {
-        self.to_substate_address().to_committee_shard(num_committees)
+    /// A shard is a division of the 256-bit shard space.
+    /// If the substate version is not known, None is returned.
+    pub fn to_committee_shard(&self, num_committees: u32) -> Option<Shard> {
+        Some(self.to_substate_address()?.to_committee_shard(num_committees))
     }
 
     pub fn to_versioned(&self) -> Option<VersionedSubstateId> {
@@ -342,11 +340,17 @@ impl From<VersionedSubstateId> for SubstateRequirement {
     }
 }
 
+impl<T: Into<SubstateId>> From<T> for SubstateRequirement {
+    fn from(value: T) -> Self {
+        Self::new(value.into(), None)
+    }
+}
+
 #[derive(Debug, thiserror::Error)]
 #[error("Failed to parse substate requirement {0}")]
 pub struct SubstateRequirementParseError(String);
 
-#[derive(Debug, Clone, Deserialize, Serialize, Eq, PartialEq, Hash)]
+#[derive(Debug, Clone, Deserialize, Serialize)]
 #[cfg_attr(
     feature = "ts",
     derive(ts_rs::TS),
@@ -412,3 +416,59 @@ impl Display for VersionedSubstateId {
         write!(f, "{}:{}", self.substate_id, self.version)
     }
 }
+
+impl TryFrom<SubstateRequirement> for VersionedSubstateId {
+    type Error = VersionedSubstateIdError;
+
+    fn try_from(value: SubstateRequirement) -> Result<Self, Self::Error> {
+        match value.version {
+            Some(v) => Ok(Self::new(value.substate_id, v)),
+            None => Err(VersionedSubstateIdError::SubstateRequirementNotVersioned(
+                value.substate_id,
+            )),
+        }
+    }
+}
+
+// Only consider the substate id in maps. This means that duplicates found if the substate id is the same regardless of
+// the version.
+impl std::hash::Hash for VersionedSubstateId {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.substate_id.hash(state);
+    }
+}
+
+impl PartialEq for VersionedSubstateId {
+    fn eq(&self, other: &Self) -> bool {
+        self.substate_id == other.substate_id
+    }
+}
+
+impl Eq for VersionedSubstateId {}
+
+impl Borrow<SubstateId> for VersionedSubstateId {
+    fn borrow(&self) -> &SubstateId {
+        &self.substate_id
+    }
+}
+
+#[derive(Debug, thiserror::Error)]
+pub enum VersionedSubstateIdError {
+    #[error("Substate requirement {0} is not versioned")]
+    SubstateRequirementNotVersioned(SubstateId),
+}
+
+#[cfg(test)]
+mod tests {
+    use tari_template_lib::models::ObjectKey;
+
+    use super::*;
+
+    #[test]
+    fn it_hashes_identically_to_a_substate_id() {
+        let substate_id = SubstateId::Component(ComponentAddress::new(ObjectKey::default()));
+        let mut set = IndexSet::new();
+        set.extend([VersionedSubstateId::new(substate_id.clone(), 0)]);
+        assert!(set.contains(&substate_id));
+    }
+}
diff --git a/dan_layer/transaction/src/unsigned_transaction.rs b/dan_layer/transaction/src/unsigned_transaction.rs
index e5c002957..4fbf0c552 100644
--- a/dan_layer/transaction/src/unsigned_transaction.rs
+++ b/dan_layer/transaction/src/unsigned_transaction.rs
@@ -1,11 +1,12 @@
 //   Copyright 2024 The Tari Project
 //   SPDX-License-Identifier: BSD-3-Clause
 
+use indexmap::IndexSet;
 use serde::{Deserialize, Serialize};
 use tari_dan_common_types::Epoch;
 use tari_engine_types::instruction::Instruction;
 
-use crate::{SubstateRequirement, Transaction};
+use crate::{SubstateRequirement, Transaction, VersionedSubstateId};
 
 #[derive(Debug, Clone, Default, Serialize, Deserialize)]
 #[cfg_attr(
@@ -17,11 +18,9 @@ pub struct UnsignedTransaction {
     pub fee_instructions: Vec<Instruction>,
     pub instructions: Vec<Instruction>,
     /// Input objects that may be downed by this transaction
-    pub inputs: Vec<SubstateRequirement>,
-    /// Input objects that must exist but cannot be downed by this transaction
-    pub input_refs: Vec<SubstateRequirement>,
+    pub inputs: IndexSet<SubstateRequirement>,
     /// Inputs filled by some authority. These are not part of the transaction hash nor the signature
-    pub filled_inputs: Vec<SubstateRequirement>,
+    pub filled_inputs: IndexSet<VersionedSubstateId>,
     pub min_epoch: Option<Epoch>,
     pub max_epoch: Option<Epoch>,
 }
@@ -31,9 +30,8 @@ impl From<&Transaction> for UnsignedTransaction {
         Self {
             fee_instructions: tx.fee_instructions().to_vec(),
             instructions: tx.instructions().to_vec(),
-            inputs: tx.inputs().to_vec(),
-            input_refs: tx.input_refs().to_vec(),
-            filled_inputs: tx.filled_inputs().to_vec(),
+            inputs: tx.inputs().clone(),
+            filled_inputs: tx.filled_inputs().clone(),
             min_epoch: tx.min_epoch(),
             max_epoch: tx.max_epoch(),
         }
diff --git a/dan_layer/wallet/storage_sqlite/Cargo.toml b/dan_layer/wallet/storage_sqlite/Cargo.toml
index 57f1f245b..3a8808465 100644
--- a/dan_layer/wallet/storage_sqlite/Cargo.toml
+++ b/dan_layer/wallet/storage_sqlite/Cargo.toml
@@ -19,13 +19,13 @@ tari_utilities = { workspace = true }
 # Just used for QuorumCertificate
 tari_dan_storage = { workspace = true }
 
-serde = { workspace = true, default-features = true }
-serde_json = { workspace = true }
+bigdecimal = { workspace = true }
+chrono = { workspace = true }
 diesel = { workspace = true, features = ["default", "sqlite", "chrono"] }
 diesel_migrations = { workspace = true }
 log = { workspace = true }
-chrono = { workspace = true }
-bigdecimal = { workspace = true }
+serde = { workspace = true, default-features = true }
+serde_json = { workspace = true }
 
 # Bundle libsqlite3
 libsqlite3-sys = { workspace = true, features = ["bundled"] }
diff --git a/dan_layer/wallet/storage_sqlite/migrations/2023-02-08-122514_initial/up.sql b/dan_layer/wallet/storage_sqlite/migrations/2023-02-08-122514_initial/up.sql
index fb5d8c1ad..00573df08 100644
--- a/dan_layer/wallet/storage_sqlite/migrations/2023-02-08-122514_initial/up.sql
+++ b/dan_layer/wallet/storage_sqlite/migrations/2023-02-08-122514_initial/up.sql
@@ -36,7 +36,7 @@ CREATE TABLE transactions
     signature         TEXT     NOT NULL,
     sender_public_key TEXT     NOT NULL,
     fee_instructions  TEXT     NOT NULL,
-    meta              TEXT     NOT NULL,
+    inputs            TEXT     NOT NULL,
     result            TEXT     NULL,
     qcs               TEXT     NULL,
     final_fee         BIGINT   NULL,
diff --git a/dan_layer/wallet/storage_sqlite/src/models/mod.rs b/dan_layer/wallet/storage_sqlite/src/models/mod.rs
index a9782c7fc..2666cadc1 100644
--- a/dan_layer/wallet/storage_sqlite/src/models/mod.rs
+++ b/dan_layer/wallet/storage_sqlite/src/models/mod.rs
@@ -14,7 +14,7 @@ mod substate;
 pub use substate::Substate;
 
 mod transaction;
-pub use transaction::{Transaction, TransactionInputs};
+pub use transaction::Transaction;
 
 mod vault;
 pub use vault::Vault;
diff --git a/dan_layer/wallet/storage_sqlite/src/models/transaction.rs b/dan_layer/wallet/storage_sqlite/src/models/transaction.rs
index e360dd16e..05a33a956 100644
--- a/dan_layer/wallet/storage_sqlite/src/models/transaction.rs
+++ b/dan_layer/wallet/storage_sqlite/src/models/transaction.rs
@@ -4,13 +4,12 @@
 use std::{str::FromStr, time::Duration};
 
 use chrono::NaiveDateTime;
-use serde::{Deserialize, Serialize};
 use tari_dan_common_types::Epoch;
 use tari_dan_wallet_sdk::{
     models::{TransactionStatus, WalletTransaction},
     storage::WalletStorageError,
 };
-use tari_transaction::{SubstateRequirement, TransactionSignature};
+use tari_transaction::TransactionSignature;
 use tari_utilities::hex::Hex;
 
 use crate::{schema::transactions, serialization::deserialize_json};
@@ -24,7 +23,7 @@ pub struct Transaction {
     pub signature: String,
     pub sender_public_key: String,
     pub fee_instructions: String,
-    pub meta: String,
+    pub inputs: String,
     pub result: Option<String>,
     pub qcs: Option<String>,
     pub final_fee: Option<i64>,
@@ -40,13 +39,6 @@ pub struct Transaction {
     pub new_account_info: Option<String>,
 }
 
-/// Struct used to keep inputs and outputs in a single field as json
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct TransactionInputs {
-    pub inputs: Vec<SubstateRequirement>,
-    pub input_refs: Vec<SubstateRequirement>,
-}
-
 impl Transaction {
     pub fn try_into_wallet_transaction(self) -> Result<WalletTransaction, WalletStorageError> {
         let signature = deserialize_json(&self.signature)?;
@@ -57,7 +49,7 @@ impl Transaction {
                 details: e.to_string(),
             })?;
         let signature = TransactionSignature::new(sender_public_key, signature);
-        let TransactionInputs { inputs, input_refs } = deserialize_json(&self.meta)?;
+        let inputs = deserialize_json(&self.inputs)?;
 
         Ok(WalletTransaction {
             transaction: tari_transaction::Transaction::new(
@@ -65,8 +57,8 @@ impl Transaction {
                 deserialize_json(&self.instructions)?,
                 signature,
                 inputs,
-                input_refs,
-                vec![],
+                // empty - We do not know filled inputs
+                Default::default(),
                 self.min_epoch.map(|epoch| Epoch(epoch as u64)),
                 self.max_epoch.map(|epoch| Epoch(epoch as u64)),
             ),
diff --git a/dan_layer/wallet/storage_sqlite/src/schema.rs b/dan_layer/wallet/storage_sqlite/src/schema.rs
index 4ce7217ef..520a917eb 100644
--- a/dan_layer/wallet/storage_sqlite/src/schema.rs
+++ b/dan_layer/wallet/storage_sqlite/src/schema.rs
@@ -108,7 +108,7 @@ diesel::table! {
         signature -> Text,
         sender_public_key -> Text,
         fee_instructions -> Text,
-        meta -> Text,
+        inputs -> Text,
         result -> Nullable<Text>,
         qcs -> Nullable<Text>,
         final_fee -> Nullable<BigInt>,
diff --git a/dan_layer/wallet/storage_sqlite/src/writer.rs b/dan_layer/wallet/storage_sqlite/src/writer.rs
index 0fa5d3b23..e3990bea1 100644
--- a/dan_layer/wallet/storage_sqlite/src/writer.rs
+++ b/dan_layer/wallet/storage_sqlite/src/writer.rs
@@ -36,7 +36,7 @@ use tari_utilities::hex::Hex;
 
 use crate::{
     diesel::ExpressionMethods,
-    models::{self, TransactionInputs},
+    models::{self},
     reader::ReadTransaction,
     serialization::serialize_json,
 };
@@ -278,10 +278,7 @@ impl WalletStoreWriter for WriteTransaction<'_> {
                 transactions::instructions.eq(serialize_json(transaction.instructions())?),
                 transactions::sender_public_key.eq(transaction.signer_public_key().to_hex()),
                 transactions::signature.eq(serialize_json(transaction.signature().signature())?),
-                transactions::meta.eq(serialize_json(&TransactionInputs {
-                    inputs: transaction.inputs().to_vec(),
-                    input_refs: transaction.input_refs().to_vec(),
-                })?),
+                transactions::inputs.eq(serialize_json(transaction.inputs())?),
                 transactions::status.eq(TransactionStatus::New.as_key_str()),
                 transactions::required_substates.eq(serialize_json(&required_substates)?),
                 transactions::new_account_info.eq(new_account_info.map(serialize_json).transpose()?),
diff --git a/integration_tests/build.rs b/integration_tests/build.rs
new file mode 100644
index 000000000..711172805
--- /dev/null
+++ b/integration_tests/build.rs
@@ -0,0 +1,7 @@
+//   Copyright 2024 The Tari Project
+//   SPDX-License-Identifier: BSD-3-Clause
+
+fn main() {
+    println!("cargo:rustc-env=TARI_NETWORK=localnet");
+    println!("cargo:rustc-env=TARI_TARGET_NETWORK=localnet");
+}
diff --git a/integration_tests/src/validator_node_cli.rs b/integration_tests/src/validator_node_cli.rs
index fecd9f29b..1d749ce81 100644
--- a/integration_tests/src/validator_node_cli.rs
+++ b/integration_tests/src/validator_node_cli.rs
@@ -63,7 +63,6 @@ pub async fn create_account(world: &mut TariWorld, account_name: String, validat
         wait_for_result: true,
         wait_for_result_timeout: Some(120),
         inputs: vec![],
-        input_refs: vec![],
         version: None,
         dump_outputs_into: None,
         account_template_address: None,
@@ -114,7 +113,6 @@ pub async fn create_component(
             wait_for_result: true,
             wait_for_result_timeout: Some(300),
             inputs: vec![],
-            input_refs: vec![],
             version: None,
             dump_outputs_into: None,
             account_template_address: None,
@@ -299,7 +297,6 @@ pub async fn call_method(
             wait_for_result: true,
             wait_for_result_timeout: Some(60),
             inputs: vec![component],
-            input_refs: vec![],
             version: None,
             dump_outputs_into: None,
             account_template_address: None,
@@ -342,7 +339,6 @@ async fn call_method_inner(
             wait_for_result: true,
             wait_for_result_timeout: Some(60),
             inputs: vec![component],
-            input_refs: vec![],
             version: None,
             dump_outputs_into: None,
             account_template_address: None,
@@ -410,28 +406,10 @@ pub async fn submit_manifest(
     // Remove inputs that have been downed
     let inputs = select_latest_version(inputs);
 
-    let input_refs = input_str
-        .split(',')
-        .map(|s| s.trim())
-        .filter(|s| s.starts_with("ref:"))
-        .flat_map(|s| {
-            world
-                .outputs
-                .get(s)
-                .unwrap_or_else(|| panic!("No outputs named {}", s.trim()))
-        })
-        .filter(|(_, addr)| !addr.substate_id.is_transaction_receipt())
-        .map(|(_, addr)| addr.clone())
-        .collect::<Vec<_>>();
-
-    // Remove inputs that have been downed
-    let inputs = select_latest_version(inputs);
-
     let args = CommonSubmitArgs {
         wait_for_result: true,
         wait_for_result_timeout: Some(60),
         inputs,
-        input_refs,
         version: None,
         dump_outputs_into: None,
         account_template_address: None,
diff --git a/utilities/tariswap_test_bench/src/tariswap.rs b/utilities/tariswap_test_bench/src/tariswap.rs
index f4b8db7c0..c8cb05a66 100644
--- a/utilities/tariswap_test_bench/src/tariswap.rs
+++ b/utilities/tariswap_test_bench/src/tariswap.rs
@@ -65,8 +65,7 @@ impl Runner {
             for (i, tariswap) in tariswaps.iter().enumerate().skip(i * 200).take(200) {
                 let account = &accounts[i % accounts.len()];
                 let transaction = Transaction::builder()
-                    .with_input_refs(vec![
-                        // Use resources as input refs to allow concurrent access.
+                    .with_inputs(vec![
                         SubstateRequirement::new(faucet.resource_address.into(), Some(0)),
                         SubstateRequirement::new(XTR2.into(), Some(0)),
                     ])
@@ -121,7 +120,7 @@ impl Runner {
                 let tariswap = &tariswaps[i % tariswaps.len()];
                 let transaction = Transaction::builder()
                     // Use resources as input refs to allow concurrent access.
-                    .with_input_refs(vec![
+                    .with_inputs(vec![
                         SubstateRequirement::new(faucet.resource_address.into(), Some(0)),
                         SubstateRequirement::new(XTR2.into(), Some(0)),
                     ])
@@ -169,7 +168,7 @@ impl Runner {
                 let tariswap = &tariswaps[i % tariswaps.len()];
                 let transaction = Transaction::builder()
                     // Use resources as input refs to allow concurrent access.
-                    .with_input_refs(vec![
+                    .with_inputs(vec![
                         SubstateRequirement::new(faucet.resource_address.into(), Some(0)),
                         SubstateRequirement::new(XTR2.into(), Some(0)),
                     ])