From fd44289fb93a8d6dad4df30faf39f44225b02459 Mon Sep 17 00:00:00 2001
From: Stan Bondi <sdbondi@users.noreply.github.com>
Date: Mon, 24 Jul 2023 13:19:56 +0200
Subject: [PATCH] fix(mempool): add transaction to state store before execution
 (#625)

Description
---
fix(mempool): add transaction to state store before execution
feat(sqlite state store): add executed_time_ms to transactions

Motivation and Context
---
Add the transaction to the state store before execution to allow missing
transactions to check if a transaction exists but is still executing.

How Has This Been Tested?
---
Existing cucumber tests, manually

What process can a PR reviewer use to test or verify this change?
---
Check that missing transaction does not request transactions that are
busy executing

Breaking Changes
---

- [ ] None
- [x] Requires data directory to be deleted
- [ ] Other - Please specify
---
 .../src/transaction_executor.rs               |   5 +-
 .../src/json_rpc/handlers.rs                  |   6 +-
 .../src/p2p/services/mempool/executor.rs      |   9 +-
 .../src/p2p/services/mempool/service.rs       |  25 ++--
 dan_layer/consensus/src/hotstuff/error.rs     |   3 +
 .../src/hotstuff/on_receive_proposal.rs       |   3 +-
 dan_layer/consensus/src/hotstuff/worker.rs    |   2 +-
 .../src/support/transaction.rs                | 134 ++++++------------
 dan_layer/indexer_lib/src/substate_scanner.rs |   2 +-
 .../up.sql                                    |  43 ++++--
 .../down.sql                                  |   4 -
 .../2023-07-12-192955_add_missing_txs/up.sql  |  16 ---
 dan_layer/state_store_sqlite/src/reader.rs    |  24 +++-
 dan_layer/state_store_sqlite/src/schema.rs    |  41 +++---
 .../src/sql_models/transaction.rs             |  38 +++--
 dan_layer/state_store_sqlite/src/writer.rs    |  13 +-
 .../consensus_models/executed_transaction.rs  |  90 ++++++++----
 dan_layer/storage/src/consensus_models/mod.rs |   2 +
 .../src/consensus_models/transaction.rs       | 128 +++++++++++++++++
 dan_layer/storage/src/state_store/mod.rs      |  14 +-
 .../tests/features/claim_burn.feature         |   1 -
 .../tests/features/transfer.feature           |   4 +
 .../tests/features/wallet_daemon.feature      |   8 ++
 23 files changed, 398 insertions(+), 217 deletions(-)
 delete mode 100644 dan_layer/state_store_sqlite/migrations/2023-07-12-192955_add_missing_txs/down.sql
 delete mode 100644 dan_layer/state_store_sqlite/migrations/2023-07-12-192955_add_missing_txs/up.sql
 create mode 100644 dan_layer/storage/src/consensus_models/transaction.rs

diff --git a/applications/tari_dan_app_utilities/src/transaction_executor.rs b/applications/tari_dan_app_utilities/src/transaction_executor.rs
index c4510dc7e..df5376868 100644
--- a/applications/tari_dan_app_utilities/src/transaction_executor.rs
+++ b/applications/tari_dan_app_utilities/src/transaction_executor.rs
@@ -1,7 +1,7 @@
 //    Copyright 2023 The Tari Project
 //    SPDX-License-Identifier: BSD-3-Clause
 
-use std::sync::Arc;
+use std::{sync::Arc, time::Instant};
 
 use tari_common_types::types::PublicKey;
 use tari_crypto::tari_utilities::ByteArray;
@@ -55,6 +55,7 @@ where TTemplateProvider: TemplateProvider<Template = LoadedTemplate>
         state_store: MemoryStateStore,
         consensus_context: ConsensusContext,
     ) -> Result<ExecutedTransaction, Self::Error> {
+        let timer = Instant::now();
         // Include ownership token for the signers of this in the auth scope
         let owner_token = get_auth_token(transaction.signer_public_key());
         let auth_params = AuthParams {
@@ -82,7 +83,7 @@ where TTemplateProvider: TemplateProvider<Template = LoadedTemplate>
             },
         };
 
-        Ok(ExecutedTransaction::new(transaction, result))
+        Ok(ExecutedTransaction::new(transaction, result, timer.elapsed()))
     }
 }
 
diff --git a/applications/tari_validator_node/src/json_rpc/handlers.rs b/applications/tari_validator_node/src/json_rpc/handlers.rs
index 307be10fe..f4f5347a2 100644
--- a/applications/tari_validator_node/src/json_rpc/handlers.rs
+++ b/applications/tari_validator_node/src/json_rpc/handlers.rs
@@ -44,7 +44,7 @@ use tari_crypto::tari_utilities::hex::Hex;
 use tari_dan_app_utilities::template_manager::interface::TemplateManagerHandle;
 use tari_dan_common_types::{optional::Optional, ShardId};
 use tari_dan_storage::{
-    consensus_models::{ExecutedTransaction, QuorumDecision, SubstateRecord},
+    consensus_models::{ExecutedTransaction, QuorumDecision, SubstateRecord, TransactionRecord},
     Ordering,
     StateStore,
 };
@@ -241,10 +241,10 @@ impl JsonRpcHandlers {
     pub async fn get_recent_transactions(&self, value: JsonRpcExtractor) -> JrpcResult {
         let answer_id = value.get_answer_id();
         let mut tx = self.state_store.create_read_tx().unwrap();
-        match ExecutedTransaction::get_paginated(&mut tx, 1000, 0, Some(Ordering::Descending)) {
+        match TransactionRecord::get_paginated(&mut tx, 1000, 0, Some(Ordering::Descending)) {
             Ok(recent_transactions) => {
                 let res = GetRecentTransactionsResponse {
-                    transactions: recent_transactions.into_iter().map(|t| t.into_transaction()).collect(),
+                    transactions: recent_transactions.into_iter().map(|t| t.transaction).collect(),
                 };
                 Ok(JsonRpcResponse::success(answer_id, res))
             },
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 d803a0839..29738249b 100644
--- a/applications/tari_validator_node/src/p2p/services/mempool/executor.rs
+++ b/applications/tari_validator_node/src/p2p/services/mempool/executor.rs
@@ -1,8 +1,6 @@
 //    Copyright 2023 The Tari Project
 //    SPDX-License-Identifier: BSD-3-Clause
 
-use std::time::{Duration, Instant};
-
 use log::*;
 use tari_dan_app_utilities::transaction_executor::{TransactionExecutor, TransactionProcessorError};
 use tari_dan_engine::{
@@ -21,7 +19,7 @@ use crate::{
 
 const LOG_TARGET: &str = "tari::dan::mempool::executor";
 
-pub(super) type ExecutionResult = (TransactionId, Duration, Result<ExecutedTransaction, MempoolError>);
+pub(super) type ExecutionResult = (TransactionId, Result<ExecutedTransaction, MempoolError>);
 
 pub async fn execute_transaction<TSubstateResolver, TExecutor>(
     transaction: Transaction,
@@ -35,13 +33,12 @@ where
 {
     let mut state_db = new_state_db();
 
-    let timer = Instant::now();
     match substate_resolver.resolve(&transaction, &mut state_db).await {
         Ok(()) => {
             let res = task::spawn_blocking(move || {
                 let id = *transaction.id();
                 let result = executor.execute(transaction, state_db, consensus_context);
-                (id, timer.elapsed(), result.map_err(MempoolError::from))
+                (id, result.map_err(MempoolError::from))
             })
             .await;
 
@@ -52,7 +49,7 @@ 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(), Duration::default(), Err(err.into())))
+            Ok((*transaction.id(), 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 22d3784a1..1bd1e0d26 100644
--- a/applications/tari_validator_node/src/p2p/services/mempool/service.rs
+++ b/applications/tari_validator_node/src/p2p/services/mempool/service.rs
@@ -29,7 +29,11 @@ use tari_dan_app_utilities::transaction_executor::{TransactionExecutor, Transact
 use tari_dan_common_types::{Epoch, ShardId};
 use tari_dan_engine::runtime::ConsensusContext;
 use tari_dan_p2p::{DanMessage, OutboundService};
-use tari_dan_storage::{consensus_models::ExecutedTransaction, StateStore};
+use tari_dan_storage::{
+    consensus_models::{ExecutedTransaction, TransactionRecord},
+    StateStore,
+    StateStoreWriteTransaction,
+};
 use tari_epoch_manager::{base_layer::EpochManagerHandle, EpochManagerReader};
 use tari_state_store_sqlite::SqliteStateStore;
 use tari_transaction::{Transaction, TransactionId};
@@ -160,15 +164,14 @@ where
             return Ok(());
         }
 
-        let transaction_processed = self.state_store.with_read_tx(|tx| {
-            let exists = ExecutedTransaction::exists(tx, transaction.id())?;
-            Ok::<_, MempoolError>(exists)
-        })?;
+        let transaction_exists = self
+            .state_store
+            .with_read_tx(|tx| TransactionRecord::exists(tx, transaction.id()))?;
 
-        if transaction_processed {
+        if transaction_exists {
             info!(
                 target: LOG_TARGET,
-                "🎱 Transaction {} already processed. Ignoring",
+                "🎱 Transaction {} already exists. Ignoring",
                 transaction.id()
             );
             return Ok(());
@@ -176,6 +179,9 @@ where
 
         self.validator.validate(&transaction).await?;
 
+        self.state_store
+            .with_write_tx(|tx| tx.transactions_insert(&transaction))?;
+
         if transaction.num_involved_shards() == 0 {
             warn!(target: LOG_TARGET, "⚠ No involved shards for payload");
         }
@@ -227,7 +233,7 @@ where
         result: Result<ExecutionResult, MempoolError>,
     ) -> Result<(), MempoolError> {
         // This is due to a bug or possibly db failure only
-        let (transaction_id, time_taken, exec_result) = result?;
+        let (transaction_id, exec_result) = result?;
 
         self.transactions.remove(&transaction_id);
         let executed = match exec_result {
@@ -237,7 +243,7 @@ where
                     "✅ Transaction {} executed successfully ({}) in {:?}",
                     executed.transaction().id(),
                     executed.result().finalize.result,
-                    time_taken
+                    executed.execution_time()
                 );
                 // We refuse to process the transaction if any input_refs are downed
                 self.check_input_refs(&executed)?;
@@ -253,6 +259,7 @@ where
                     transaction_id,
                     e.to_string()
                 );
+
                 return Ok(());
             },
         };
diff --git a/dan_layer/consensus/src/hotstuff/error.rs b/dan_layer/consensus/src/hotstuff/error.rs
index 43f1aa0e3..11d720a76 100644
--- a/dan_layer/consensus/src/hotstuff/error.rs
+++ b/dan_layer/consensus/src/hotstuff/error.rs
@@ -9,6 +9,7 @@ use tari_dan_storage::{
 };
 use tari_epoch_manager::EpochManagerError;
 use tari_mmr::BalancedBinaryMerkleProofError;
+use tari_transaction::TransactionId;
 
 #[derive(Debug, thiserror::Error)]
 pub enum HotStuffError {
@@ -40,6 +41,8 @@ pub enum HotStuffError {
     InvalidVoteSignature { signer_public_key: PublicKey },
     #[error("Transaction pool error: {0}")]
     TransactionPoolError(#[from] TransactionPoolError),
+    #[error("Transaction {transaction_id} does not exist")]
+    TransactionDoesNotExist { transaction_id: TransactionId },
     #[error("Received vote for unknown block {block_id} from {sent_by}")]
     ReceivedVoteForUnknownBlock { block_id: BlockId, sent_by: String },
 }
diff --git a/dan_layer/consensus/src/hotstuff/on_receive_proposal.rs b/dan_layer/consensus/src/hotstuff/on_receive_proposal.rs
index 38678313b..f16b843ae 100644
--- a/dan_layer/consensus/src/hotstuff/on_receive_proposal.rs
+++ b/dan_layer/consensus/src/hotstuff/on_receive_proposal.rs
@@ -28,6 +28,7 @@ use tari_dan_storage::{
         SubstateRecord,
         TransactionPool,
         TransactionPoolStage,
+        TransactionRecord,
     },
     StateStore,
     StateStoreReadTransaction,
@@ -130,7 +131,7 @@ where TConsensusSpec: ConsensusSpec
         let mut missing_tx_ids = Vec::new();
         self.store.with_read_tx(|tx| {
             for tx_id in block.all_transaction_ids() {
-                if !ExecutedTransaction::exists(tx, tx_id)? {
+                if !TransactionRecord::exists(tx, tx_id)? {
                     missing_tx_ids.push(*tx_id);
                 }
             }
diff --git a/dan_layer/consensus/src/hotstuff/worker.rs b/dan_layer/consensus/src/hotstuff/worker.rs
index f060ea41b..afa541f5d 100644
--- a/dan_layer/consensus/src/hotstuff/worker.rs
+++ b/dan_layer/consensus/src/hotstuff/worker.rs
@@ -205,7 +205,7 @@ where
             executed.transaction().id()
         );
         self.state_store.with_write_tx(|tx| {
-            executed.insert(tx)?;
+            executed.upsert(tx)?;
 
             let decision = if executed.result().finalize.is_accept() {
                 Decision::Commit
diff --git a/dan_layer/consensus_tests/src/support/transaction.rs b/dan_layer/consensus_tests/src/support/transaction.rs
index 24b8c3763..3a6ba8e42 100644
--- a/dan_layer/consensus_tests/src/support/transaction.rs
+++ b/dan_layer/consensus_tests/src/support/transaction.rs
@@ -1,7 +1,7 @@
 //   Copyright 2023 The Tari Project
 //   SPDX-License-Identifier: BSD-3-Clause
 
-use std::iter;
+use std::{iter, time::Duration};
 
 use tari_common_types::types::PrivateKey;
 use tari_dan_storage::consensus_models::{Decision, ExecutedTransaction};
@@ -17,40 +17,43 @@ use crate::support::helpers::random_shard_in_bucket;
 
 pub fn build_transaction_from(tx: Transaction, decision: Decision, fee: u64) -> ExecutedTransaction {
     let tx_id = *tx.id();
-    ExecutedTransaction::new(tx, ExecuteResult {
-        finalize: FinalizeResult::new(
-            tx_id.into_array().into(),
-            vec![],
-            vec![],
-            if decision.is_commit() {
-                TransactionResult::Accept(SubstateDiff::new())
-            } else {
-                TransactionResult::Reject(RejectReason::ExecutionFailure("Test failure".to_string()))
-            },
-            FeeCostBreakdown {
-                total_fees_charged: fee.try_into().unwrap(),
-                breakdown: vec![],
-            },
-        ),
-        transaction_failure: None,
-        fee_receipt: Some(FeeReceipt {
-            total_fee_payment: fee.try_into().unwrap(),
-            fee_resource: ResourceContainer::Confidential {
-                address: "resource_0000000000000000000000000000000000000000000000000000000000000000"
-                    .parse()
-                    .unwrap(),
-                commitments: Default::default(),
-                revealed_amount: fee.try_into().unwrap(),
-            },
-            cost_breakdown: vec![],
-        }),
-    })
+    ExecutedTransaction::new(
+        tx,
+        ExecuteResult {
+            finalize: FinalizeResult::new(
+                tx_id.into_array().into(),
+                vec![],
+                vec![],
+                if decision.is_commit() {
+                    TransactionResult::Accept(SubstateDiff::new())
+                } else {
+                    TransactionResult::Reject(RejectReason::ExecutionFailure("Test failure".to_string()))
+                },
+                FeeCostBreakdown {
+                    total_fees_charged: fee.try_into().unwrap(),
+                    breakdown: vec![],
+                },
+            ),
+            transaction_failure: None,
+            fee_receipt: Some(FeeReceipt {
+                total_fee_payment: fee.try_into().unwrap(),
+                fee_resource: ResourceContainer::Confidential {
+                    address: "resource_0000000000000000000000000000000000000000000000000000000000000000"
+                        .parse()
+                        .unwrap(),
+                    commitments: Default::default(),
+                    revealed_amount: fee.try_into().unwrap(),
+                },
+                cost_breakdown: vec![],
+            }),
+        },
+        Duration::from_secs(0),
+    )
 }
 
 pub fn build_transaction(decision: Decision, fee: u64, num_shards: usize, num_committees: u32) -> ExecutedTransaction {
     let k = PrivateKey::default();
-
-    let mut tx = tari_transaction::Transaction::builder().sign(&k).build();
+    let mut tx = Transaction::builder().sign(&k).build();
     for bucket in 0..num_committees {
         // We fill these outputs so that the test VNs dont have to have any UP substates
         // Equal potion of shards to each committee
@@ -60,66 +63,17 @@ pub fn build_transaction(decision: Decision, fee: u64, num_shards: usize, num_co
         );
     }
 
-    let tx_id = *tx.id();
-    ExecutedTransaction::new(tx, ExecuteResult {
-        finalize: FinalizeResult::new(
-            tx_id.into_array().into(),
-            vec![],
-            vec![],
-            if decision.is_commit() {
-                TransactionResult::Accept(SubstateDiff::new())
-            } else {
-                TransactionResult::Reject(RejectReason::ExecutionFailure("Test failure".to_string()))
-            },
-            FeeCostBreakdown {
-                total_fees_charged: fee.try_into().unwrap(),
-                breakdown: vec![],
-            },
-        ),
-        transaction_failure: None,
-        fee_receipt: Some(FeeReceipt {
-            total_fee_payment: fee.try_into().unwrap(),
-            fee_resource: ResourceContainer::Confidential {
-                address: "resource_0000000000000000000000000000000000000000000000000000000000000000"
-                    .parse()
-                    .unwrap(),
-                commitments: Default::default(),
-                revealed_amount: fee.try_into().unwrap(),
-            },
-            cost_breakdown: vec![],
-        }),
-    })
+    build_transaction_from(tx, decision, fee)
 }
 
 pub fn change_decision(tx: ExecutedTransaction, new_decision: Decision) -> ExecutedTransaction {
-    let total_fees_charged = tx.result().fee_receipt.as_ref().unwrap().total_fee_payment;
-    let tx_id = *tx.transaction().id();
-    ExecutedTransaction::new(tx.into_transaction(), ExecuteResult {
-        finalize: FinalizeResult::new(
-            tx_id.into_array().into(),
-            vec![],
-            vec![],
-            if new_decision.is_commit() {
-                TransactionResult::Accept(SubstateDiff::new())
-            } else {
-                TransactionResult::Reject(RejectReason::ExecutionFailure("Test failure".to_string()))
-            },
-            FeeCostBreakdown {
-                total_fees_charged,
-                breakdown: vec![],
-            },
-        ),
-        transaction_failure: None,
-        fee_receipt: Some(FeeReceipt {
-            total_fee_payment: total_fees_charged,
-            fee_resource: ResourceContainer::Confidential {
-                address: "resource_0000000000000000000000000000000000000000000000000000000000000000"
-                    .parse()
-                    .unwrap(),
-                commitments: Default::default(),
-                revealed_amount: total_fees_charged,
-            },
-            cost_breakdown: vec![],
-        }),
-    })
+    let total_fees_charged = tx
+        .result()
+        .fee_receipt
+        .as_ref()
+        .unwrap()
+        .total_fee_payment
+        .as_u64_checked()
+        .unwrap();
+    build_transaction_from(tx.into_transaction(), new_decision, total_fees_charged)
 }
diff --git a/dan_layer/indexer_lib/src/substate_scanner.rs b/dan_layer/indexer_lib/src/substate_scanner.rs
index b26ff6ffb..4a6d4e200 100644
--- a/dan_layer/indexer_lib/src/substate_scanner.rs
+++ b/dan_layer/indexer_lib/src/substate_scanner.rs
@@ -202,7 +202,7 @@ where
 
         error!(
             target: LOG_TARGET,
-            "Could not get substate {} from any of the validator nodes", shard,
+            "Could not get substate for shard {} from any of the validator nodes", shard,
         );
 
         if let Some(e) = last_error {
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 4b073efd3..e95259e97 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
@@ -113,19 +113,20 @@ create table locked_block
 
 create table transactions
 (
-    id               integer   not null primary key AUTOINCREMENT,
-    transaction_id   text      not null,
-    fee_instructions text      not NULL,
-    instructions     text      not NULL,
-    signature        text      not NULL,
-    inputs           text      not NULL,
-    input_refs       text      not NULL,
-    outputs          text      not NULL,
-    filled_inputs    text      not NULL,
-    filled_outputs   text      not NULL,
-    result           text      not NULL,
+    id                integer   not null primary key AUTOINCREMENT,
+    transaction_id    text      not null,
+    fee_instructions  text      not NULL,
+    instructions      text      not NULL,
+    signature         text      not NULL,
+    inputs            text      not NULL,
+    input_refs        text      not NULL,
+    outputs           text      not NULL,
+    filled_inputs     text      not NULL,
+    filled_outputs    text      not NULL,
+    result            text      NULL,
+    execution_time_ms bigint    NULL,
     final_decision   text      NULL,
-    created_at       timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP
+    created_at        timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP
 );
 
 create unique index transactions_uniq_idx_id on transactions (transaction_id);
@@ -159,4 +160,20 @@ create table votes
     signature        text      not NULL,
     merkle_proof     text      not NULL,
     created_at       timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP
-);
\ No newline at end of file
+);
+
+CREATE TABLE block_missing_txs
+(
+    id              integer   not NULL PRIMARY KEY AUTOINCREMENT,
+    transaction_ids text      not NULL,
+    block_id        text      not NULL,
+    created_at      timestamp not NULL DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE TABLE missing_tx
+(
+    id              integer   not NULL primary key AUTOINCREMENT,
+    transaction_id  text      not NULL,
+    block_id        text      not NULL,
+    created_at      timestamp not NULL DEFAULT CURRENT_TIMESTAMP
+);
diff --git a/dan_layer/state_store_sqlite/migrations/2023-07-12-192955_add_missing_txs/down.sql b/dan_layer/state_store_sqlite/migrations/2023-07-12-192955_add_missing_txs/down.sql
deleted file mode 100644
index bc5c99e05..000000000
--- a/dan_layer/state_store_sqlite/migrations/2023-07-12-192955_add_missing_txs/down.sql
+++ /dev/null
@@ -1,4 +0,0 @@
--- This file should undo anything in `up.sql`
-
-DROP TABLE missing_txs
-DROP TABLE missing_txs_in_block
diff --git a/dan_layer/state_store_sqlite/migrations/2023-07-12-192955_add_missing_txs/up.sql b/dan_layer/state_store_sqlite/migrations/2023-07-12-192955_add_missing_txs/up.sql
deleted file mode 100644
index 6e06bad2f..000000000
--- a/dan_layer/state_store_sqlite/migrations/2023-07-12-192955_add_missing_txs/up.sql
+++ /dev/null
@@ -1,16 +0,0 @@
--- Your SQL goes here
-CREATE TABLE block_missing_txs
-(
-    id              integer   not NULL PRIMARY KEY AUTOINCREMENT,
-    transaction_ids text      not NULL,
-    created_at      timestamp not NULL DEFAULT CURRENT_TIMESTAMP,
-    block_id        text      not NULL
-);
-
-CREATE TABLE missing_tx
-(
-    id              integer   not NULL primary key AUTOINCREMENT,
-    transaction_id  text      not NULL,
-    created_at      timestamp not NULL DEFAULT CURRENT_TIMESTAMP,
-    block_id        text      not NULL
-);
diff --git a/dan_layer/state_store_sqlite/src/reader.rs b/dan_layer/state_store_sqlite/src/reader.rs
index aa8c58000..9c3dd8252 100644
--- a/dan_layer/state_store_sqlite/src/reader.rs
+++ b/dan_layer/state_store_sqlite/src/reader.rs
@@ -20,7 +20,6 @@ use tari_dan_storage::{
     consensus_models::{
         Block,
         BlockId,
-        ExecutedTransaction,
         HighQc,
         LastExecuted,
         LastProposed,
@@ -32,6 +31,7 @@ use tari_dan_storage::{
         SubstateRecord,
         TransactionPoolRecord,
         TransactionPoolStage,
+        TransactionRecord,
         Vote,
     },
     Ordering,
@@ -160,7 +160,7 @@ impl StateStoreReadTransaction for SqliteStateStoreReadTransaction<'_> {
         high_qc.try_into()
     }
 
-    fn transactions_get(&mut self, tx_id: &TransactionId) -> Result<ExecutedTransaction, StorageError> {
+    fn transactions_get(&mut self, tx_id: &TransactionId) -> Result<TransactionRecord, StorageError> {
         use crate::schema::transactions;
 
         let transaction = transactions::table
@@ -174,10 +174,26 @@ impl StateStoreReadTransaction for SqliteStateStoreReadTransaction<'_> {
         transaction.try_into()
     }
 
+    fn transactions_exists(&mut self, tx_id: &TransactionId) -> Result<bool, StorageError> {
+        use crate::schema::transactions;
+
+        let exists = transactions::table
+            .count()
+            .filter(transactions::transaction_id.eq(serialize_hex(tx_id)))
+            .limit(1)
+            .get_result::<i64>(self.connection())
+            .map_err(|e| SqliteStorageError::DieselError {
+                operation: "transactions_exists",
+                source: e,
+            })?;
+
+        Ok(exists > 0)
+    }
+
     fn transactions_get_any<'a, I: IntoIterator<Item = &'a TransactionId>>(
         &mut self,
         tx_ids: I,
-    ) -> Result<Vec<ExecutedTransaction>, StorageError> {
+    ) -> Result<Vec<TransactionRecord>, StorageError> {
         use crate::schema::transactions;
 
         let tx_ids: Vec<String> = tx_ids.into_iter().map(serialize_hex).collect();
@@ -201,7 +217,7 @@ impl StateStoreReadTransaction for SqliteStateStoreReadTransaction<'_> {
         limit: u64,
         offset: u64,
         asc_desc_created_at: Option<Ordering>,
-    ) -> Result<Vec<ExecutedTransaction>, StorageError> {
+    ) -> Result<Vec<TransactionRecord>, StorageError> {
         use crate::schema::transactions;
 
         let mut query = transactions::table.into_boxed();
diff --git a/dan_layer/state_store_sqlite/src/schema.rs b/dan_layer/state_store_sqlite/src/schema.rs
index 4ed5c3b04..29d7ccfb1 100644
--- a/dan_layer/state_store_sqlite/src/schema.rs
+++ b/dan_layer/state_store_sqlite/src/schema.rs
@@ -1,5 +1,14 @@
 // @generated automatically by Diesel CLI.
 
+diesel::table! {
+    block_missing_txs (id) {
+        id -> Integer,
+        transaction_ids -> Text,
+        block_id -> Text,
+        created_at -> Timestamp,
+    }
+}
+
 diesel::table! {
     blocks (id) {
         id -> Integer,
@@ -15,24 +24,6 @@ diesel::table! {
     }
 }
 
-diesel::table! {
-    block_missing_txs(id) {
-        id -> Integer,
-        block_id -> Text,
-        transaction_ids -> Text,
-        created_at -> Timestamp,
-    }
-}
-
-diesel::table! {
-    missing_tx(id) {
-        id -> Integer,
-        transaction_id -> Text,
-        block_id -> Text,
-        created_at -> Timestamp,
-    }
-}
-
 diesel::table! {
     high_qcs (id) {
         id -> Integer,
@@ -93,6 +84,15 @@ diesel::table! {
     }
 }
 
+diesel::table! {
+    missing_tx (id) {
+        id -> Integer,
+        transaction_id -> Text,
+        block_id -> Text,
+        created_at -> Timestamp,
+    }
+}
+
 diesel::table! {
     quorum_certificates (id) {
         id -> Integer,
@@ -155,7 +155,8 @@ diesel::table! {
         outputs -> Text,
         filled_inputs -> Text,
         filled_outputs -> Text,
-        result -> Text,
+        result -> Nullable<Text>,
+        execution_time_ms -> Nullable<BigInt>,
         final_decision -> Nullable<Text>,
         created_at -> Timestamp,
     }
@@ -176,6 +177,7 @@ diesel::table! {
 }
 
 diesel::allow_tables_to_appear_in_same_query!(
+    block_missing_txs,
     blocks,
     high_qcs,
     last_executed,
@@ -183,6 +185,7 @@ diesel::allow_tables_to_appear_in_same_query!(
     last_voted,
     leaf_blocks,
     locked_block,
+    missing_tx,
     quorum_certificates,
     substates,
     transaction_pool,
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 51043f425..dc7ebd9fe 100644
--- a/dan_layer/state_store_sqlite/src/sql_models/transaction.rs
+++ b/dan_layer/state_store_sqlite/src/sql_models/transaction.rs
@@ -1,7 +1,7 @@
 //   Copyright 2023 The Tari Project
 //   SPDX-License-Identifier: BSD-3-Clause
 
-use std::str::FromStr;
+use std::{str::FromStr, time::Duration};
 
 use diesel::Queryable;
 use tari_dan_storage::{consensus_models, consensus_models::Decision, StorageError};
@@ -17,11 +17,12 @@ pub struct Transaction {
     pub instructions: String,
     pub signature: String,
     pub inputs: String,
-    pub exists: String,
+    pub input_refs: String,
     pub outputs: String,
     pub filled_inputs: String,
     pub filled_outputs: String,
-    pub result: String,
+    pub result: Option<String>,
+    pub execution_time_ms: Option<i64>,
     pub final_decision: Option<String>,
     pub created_at: PrimitiveDateTime,
 }
@@ -35,7 +36,7 @@ impl TryFrom<Transaction> for tari_transaction::Transaction {
         let signature = deserialize_json(&value.signature)?;
 
         let inputs = deserialize_json(&value.inputs)?;
-        let exists = deserialize_json(&value.exists)?;
+        let input_refs = deserialize_json(&value.input_refs)?;
         let outputs = deserialize_json(&value.outputs)?;
         let filled_inputs = deserialize_json(&value.filled_inputs)?;
         let filled_outputs = deserialize_json(&value.filled_outputs)?;
@@ -45,7 +46,7 @@ impl TryFrom<Transaction> for tari_transaction::Transaction {
             instructions,
             signature,
             inputs,
-            exists,
+            input_refs,
             outputs,
             filled_inputs,
             filled_outputs,
@@ -53,7 +54,7 @@ impl TryFrom<Transaction> for tari_transaction::Transaction {
     }
 }
 
-impl TryFrom<Transaction> for consensus_models::ExecutedTransaction {
+impl TryFrom<Transaction> for consensus_models::TransactionRecord {
     type Error = StorageError;
 
     fn try_from(value: Transaction) -> Result<Self, Self::Error> {
@@ -70,7 +71,28 @@ impl TryFrom<Transaction> for consensus_models::ExecutedTransaction {
                     value.final_decision.as_ref().unwrap()
                 ),
             })?;
-        let result = deserialize_json(&value.result)?;
-        Ok(Self::new_with_final_decision(value.try_into()?, result, final_decision))
+        let execution_time = value.execution_time_ms.map(|ms| Duration::from_millis(ms as u64));
+        let result = value.result.as_deref().map(deserialize_json).transpose()?;
+        Ok(Self::new_with_details(
+            value.try_into()?,
+            result,
+            execution_time,
+            final_decision,
+        ))
+    }
+}
+
+impl TryFrom<Transaction> for consensus_models::ExecutedTransaction {
+    type Error = StorageError;
+
+    fn try_from(value: Transaction) -> Result<Self, Self::Error> {
+        let rec = consensus_models::TransactionRecord::try_from(value)?;
+
+        if rec.result.is_none() {
+            return Err(StorageError::QueryError {
+                reason: format!("Transaction {} has not executed", rec.transaction.id()),
+            });
+        }
+        rec.try_into()
     }
 }
diff --git a/dan_layer/state_store_sqlite/src/writer.rs b/dan_layer/state_store_sqlite/src/writer.rs
index 6595d85e8..a426f4d17 100644
--- a/dan_layer/state_store_sqlite/src/writer.rs
+++ b/dan_layer/state_store_sqlite/src/writer.rs
@@ -33,7 +33,7 @@ use tari_dan_storage::{
     StateStoreWriteTransaction,
     StorageError,
 };
-use tari_transaction::TransactionId;
+use tari_transaction::{Transaction, TransactionId};
 use time::PrimitiveDateTime;
 
 use crate::{
@@ -331,24 +331,19 @@ impl StateStoreWriteTransaction for SqliteStateStoreWriteTransaction<'_> {
         Ok(())
     }
 
-    fn transactions_insert(&mut self, executed_transaction: &ExecutedTransaction) -> Result<(), StorageError> {
+    fn transactions_insert(&mut self, transaction: &Transaction) -> Result<(), StorageError> {
         use crate::schema::transactions;
 
-        let transaction = executed_transaction.transaction();
-        let result = executed_transaction.result();
-
         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::result.eq(serialize_json(result)?),
             transactions::signature.eq(serialize_json(transaction.signature())?),
             transactions::inputs.eq(serialize_json(transaction.inputs())?),
             transactions::input_refs.eq(serialize_json(transaction.input_refs())?),
             transactions::outputs.eq(serialize_json(transaction.outputs())?),
             transactions::filled_inputs.eq(serialize_json(transaction.filled_inputs())?),
             transactions::filled_outputs.eq(serialize_json(transaction.filled_outputs())?),
-            transactions::final_decision.eq(executed_transaction.final_decision().map(|d| d.to_string())),
         );
 
         diesel::insert_into(transactions::table)
@@ -362,7 +357,7 @@ impl StateStoreWriteTransaction for SqliteStateStoreWriteTransaction<'_> {
         Ok(())
     }
 
-    fn transactions_update(&mut self, executed_transaction: &ExecutedTransaction) -> Result<(), StorageError> {
+    fn executed_transactions_update(&mut self, executed_transaction: &ExecutedTransaction) -> Result<(), StorageError> {
         use crate::schema::transactions;
 
         let transaction = executed_transaction.transaction();
@@ -372,6 +367,8 @@ impl StateStoreWriteTransaction for SqliteStateStoreWriteTransaction<'_> {
             transactions::result.eq(serialize_json(result)?),
             transactions::filled_inputs.eq(serialize_json(transaction.filled_inputs())?),
             transactions::filled_outputs.eq(serialize_json(transaction.filled_outputs())?),
+            transactions::execution_time_ms
+                .eq(i64::try_from(executed_transaction.execution_time().as_millis()).unwrap_or(i64::MAX)),
             transactions::final_decision.eq(executed_transaction.final_decision().map(|d| d.to_string())),
         );
 
diff --git a/dan_layer/storage/src/consensus_models/executed_transaction.rs b/dan_layer/storage/src/consensus_models/executed_transaction.rs
index d90604787..d6c2c5025 100644
--- a/dan_layer/storage/src/consensus_models/executed_transaction.rs
+++ b/dan_layer/storage/src/consensus_models/executed_transaction.rs
@@ -4,6 +4,7 @@
 use std::{
     collections::{HashMap, HashSet},
     ops::DerefMut,
+    time::Duration,
 };
 
 use serde::{Deserialize, Serialize};
@@ -12,24 +13,26 @@ use tari_engine_types::commit_result::{ExecuteResult, FinalizeResult, RejectReas
 use tari_transaction::{Transaction, TransactionId};
 
 use crate::{
-    consensus_models::{Decision, Evidence},
-    Ordering,
+    consensus_models::{Decision, Evidence, TransactionRecord},
     StateStoreReadTransaction,
     StateStoreWriteTransaction,
     StorageError,
 };
+
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct ExecutedTransaction {
     transaction: Transaction,
     result: ExecuteResult,
+    execution_time: Duration,
     final_decision: Option<Decision>,
 }
 
 impl ExecutedTransaction {
-    pub fn new(transaction: Transaction, result: ExecuteResult) -> Self {
+    pub fn new(transaction: Transaction, result: ExecuteResult, execution_time: Duration) -> Self {
         Self {
             transaction,
             result,
+            execution_time,
             final_decision: None,
         }
     }
@@ -37,15 +40,25 @@ impl ExecutedTransaction {
     pub fn new_with_final_decision(
         transaction: Transaction,
         result: ExecuteResult,
+        execution_time: Duration,
         final_decision: Option<Decision>,
     ) -> Self {
         Self {
             transaction,
             result,
+            execution_time,
             final_decision,
         }
     }
 
+    pub fn as_decision(&self) -> Decision {
+        if self.result.finalize.is_accept() {
+            Decision::Commit
+        } else {
+            Decision::Abort
+        }
+    }
+
     pub fn transaction(&self) -> &Transaction {
         &self.transaction
     }
@@ -84,6 +97,14 @@ impl ExecutedTransaction {
         self.result
     }
 
+    pub fn execution_time(&self) -> Duration {
+        self.execution_time
+    }
+
+    pub fn dissolve(self) -> (Transaction, ExecuteResult) {
+        (self.transaction, self.result)
+    }
+
     pub fn to_initial_evidence(&self) -> Evidence {
         self.transaction
             .involved_shards_iter()
@@ -107,15 +128,16 @@ impl ExecutedTransaction {
 
 impl ExecutedTransaction {
     pub fn insert<TTx: StateStoreWriteTransaction>(&self, tx: &mut TTx) -> Result<(), StorageError> {
-        tx.transactions_insert(self)
+        tx.transactions_insert(self.transaction())?;
+        tx.executed_transactions_update(self)
     }
 
-    pub fn save<TTx>(&self, tx: &mut TTx) -> Result<(), StorageError>
+    pub fn upsert<TTx>(&self, tx: &mut TTx) -> Result<(), StorageError>
     where
         TTx: StateStoreWriteTransaction + DerefMut,
         TTx::Target: StateStoreReadTransaction,
     {
-        if Self::exists(tx.deref_mut(), self.transaction.id())? {
+        if TransactionRecord::exists(tx.deref_mut(), self.transaction.id())? {
             self.update(tx)
         } else {
             self.insert(tx)
@@ -123,36 +145,35 @@ impl ExecutedTransaction {
     }
 
     pub fn update<TTx: StateStoreWriteTransaction>(&self, tx: &mut TTx) -> Result<(), StorageError> {
-        tx.transactions_update(self)
+        tx.executed_transactions_update(self)
     }
 
     pub fn get<TTx: StateStoreReadTransaction>(tx: &mut TTx, tx_id: &TransactionId) -> Result<Self, StorageError> {
-        tx.transactions_get(tx_id)
+        let rec = tx.transactions_get(tx_id)?;
+        if rec.result.is_none() {
+            return Err(StorageError::NotFound {
+                item: "ExecutedTransaction".to_string(),
+                key: tx_id.to_string(),
+            });
+        }
+
+        // This should never fail as we just checked that the transaction has been executed
+        rec.try_into()
     }
 
-    pub fn exists<TTx: StateStoreReadTransaction + ?Sized>(
-        tx: &mut TTx,
-        tx_id: &TransactionId,
-    ) -> Result<bool, StorageError> {
-        // TODO: optimise
-        let t = tx.transactions_get(tx_id).optional()?;
-        Ok(t.is_some())
+    pub fn exists<TTx: StateStoreReadTransaction + ?Sized>(&self, tx: &mut TTx) -> Result<bool, StorageError> {
+        match tx.transactions_get(self.transaction.id()).optional()? {
+            Some(rec) => Ok(rec.result.is_some()),
+            None => Ok(false),
+        }
     }
 
     pub fn get_any<'a, TTx: StateStoreReadTransaction, I: IntoIterator<Item = &'a TransactionId>>(
         tx: &mut TTx,
         tx_ids: I,
     ) -> Result<Vec<Self>, StorageError> {
-        tx.transactions_get_any(tx_ids)
-    }
-
-    pub fn get_paginated<TTx: StateStoreReadTransaction>(
-        tx: &mut TTx,
-        limit: u64,
-        offset: u64,
-        ordering: Option<Ordering>,
-    ) -> Result<Vec<Self>, StorageError> {
-        tx.transactions_get_paginated(limit, offset, ordering)
+        let recs = tx.transactions_get_any(tx_ids)?;
+        recs.into_iter().map(|rec| rec.try_into()).collect()
     }
 
     pub fn get_involved_shards<'a, TTx: StateStoreReadTransaction, I: IntoIterator<Item = &'a TransactionId>>(
@@ -171,3 +192,22 @@ impl ExecutedTransaction {
             .collect())
     }
 }
+
+impl TryFrom<TransactionRecord> for ExecutedTransaction {
+    type Error = StorageError;
+
+    fn try_from(value: TransactionRecord) -> Result<Self, Self::Error> {
+        if value.result.is_none() {
+            return Err(StorageError::QueryError {
+                reason: format!("Transaction {} has not yet executed", value.transaction.id()),
+            });
+        }
+
+        Ok(Self {
+            transaction: value.transaction,
+            result: value.result.unwrap(),
+            execution_time: value.execution_time.unwrap_or_default(),
+            final_decision: value.final_decision,
+        })
+    }
+}
diff --git a/dan_layer/storage/src/consensus_models/mod.rs b/dan_layer/storage/src/consensus_models/mod.rs
index 0a4443c6a..2ecd80017 100644
--- a/dan_layer/storage/src/consensus_models/mod.rs
+++ b/dan_layer/storage/src/consensus_models/mod.rs
@@ -13,6 +13,7 @@ mod locked_block;
 mod quorum;
 mod quorum_certificate;
 mod substate;
+mod transaction;
 mod transaction_decision;
 mod transaction_pool;
 mod vote;
@@ -30,6 +31,7 @@ pub use locked_block::*;
 pub use quorum::*;
 pub use quorum_certificate::*;
 pub use substate::*;
+pub use transaction::*;
 pub use transaction_decision::*;
 pub use transaction_pool::*;
 pub use vote::*;
diff --git a/dan_layer/storage/src/consensus_models/transaction.rs b/dan_layer/storage/src/consensus_models/transaction.rs
new file mode 100644
index 000000000..0299ce1b7
--- /dev/null
+++ b/dan_layer/storage/src/consensus_models/transaction.rs
@@ -0,0 +1,128 @@
+//   Copyright 2023 The Tari Project
+//   SPDX-License-Identifier: BSD-3-Clause
+
+use std::{
+    collections::{HashMap, HashSet},
+    ops::DerefMut,
+    time::Duration,
+};
+
+use serde::{Deserialize, Serialize};
+use tari_dan_common_types::ShardId;
+use tari_engine_types::commit_result::ExecuteResult;
+use tari_transaction::{Transaction, TransactionId};
+
+use crate::{
+    consensus_models::{Decision, ExecutedTransaction},
+    Ordering,
+    StateStoreReadTransaction,
+    StateStoreWriteTransaction,
+    StorageError,
+};
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct TransactionRecord {
+    pub transaction: Transaction,
+    pub result: Option<ExecuteResult>,
+    pub execution_time: Option<Duration>,
+    pub final_decision: Option<Decision>,
+}
+
+impl TransactionRecord {
+    pub fn new(transaction: Transaction) -> Self {
+        Self {
+            transaction,
+            result: None,
+            execution_time: None,
+            final_decision: None,
+        }
+    }
+
+    pub fn new_with_details(
+        transaction: Transaction,
+        result: Option<ExecuteResult>,
+        execution_time: Option<Duration>,
+        final_decision: Option<Decision>,
+    ) -> Self {
+        Self {
+            transaction,
+            result,
+            execution_time,
+            final_decision,
+        }
+    }
+}
+
+impl TransactionRecord {
+    pub fn insert<TTx: StateStoreWriteTransaction>(&self, tx: &mut TTx) -> Result<(), StorageError> {
+        tx.transactions_insert(&self.transaction)
+    }
+
+    pub fn save<TTx>(&self, tx: &mut TTx) -> Result<(), StorageError>
+    where
+        TTx: StateStoreWriteTransaction + DerefMut,
+        TTx::Target: StateStoreReadTransaction,
+    {
+        if !Self::exists(tx.deref_mut(), self.transaction.id())? {
+            self.insert(tx)?;
+        }
+        Ok(())
+    }
+
+    pub fn get<TTx: StateStoreReadTransaction>(tx: &mut TTx, tx_id: &TransactionId) -> Result<Self, StorageError> {
+        tx.transactions_get(tx_id)
+    }
+
+    pub fn exists<TTx: StateStoreReadTransaction + ?Sized>(
+        tx: &mut TTx,
+        tx_id: &TransactionId,
+    ) -> Result<bool, StorageError> {
+        tx.transactions_exists(tx_id)
+    }
+
+    pub fn get_any<'a, TTx: StateStoreReadTransaction, I: IntoIterator<Item = &'a TransactionId>>(
+        tx: &mut TTx,
+        tx_ids: I,
+    ) -> Result<Vec<Self>, StorageError> {
+        tx.transactions_get_any(tx_ids)
+    }
+
+    pub fn get_paginated<TTx: StateStoreReadTransaction>(
+        tx: &mut TTx,
+        limit: u64,
+        offset: u64,
+        ordering: Option<Ordering>,
+    ) -> Result<Vec<Self>, StorageError> {
+        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<ShardId>>, StorageError> {
+        let transactions = Self::get_any(tx, transactions)?;
+        Ok(transactions
+            .into_iter()
+            .map(|t| {
+                (
+                    *t.transaction.id(),
+                    t.transaction.involved_shards_iter().copied().collect(),
+                )
+            })
+            .collect())
+    }
+}
+
+impl From<ExecutedTransaction> for TransactionRecord {
+    fn from(tx: ExecutedTransaction) -> Self {
+        let execution_time = tx.execution_time();
+        let final_decision = tx.final_decision();
+        let (transaction, result) = tx.dissolve();
+        Self {
+            transaction,
+            result: Some(result),
+            execution_time: Some(execution_time),
+            final_decision,
+        }
+    }
+}
diff --git a/dan_layer/storage/src/state_store/mod.rs b/dan_layer/storage/src/state_store/mod.rs
index cda07a732..08d7e0c5c 100644
--- a/dan_layer/storage/src/state_store/mod.rs
+++ b/dan_layer/storage/src/state_store/mod.rs
@@ -8,7 +8,7 @@ use std::{
 
 use tari_common_types::types::FixedHash;
 use tari_dan_common_types::{Epoch, ShardId};
-use tari_transaction::TransactionId;
+use tari_transaction::{Transaction, TransactionId};
 
 use crate::{
     consensus_models::{
@@ -31,6 +31,7 @@ use crate::{
         TransactionAtom,
         TransactionPoolRecord,
         TransactionPoolStage,
+        TransactionRecord,
         Vote,
     },
     StorageError,
@@ -79,17 +80,18 @@ pub trait StateStoreReadTransaction {
     fn locked_block_get(&mut self, epoch: Epoch) -> Result<LockedBlock, StorageError>;
     fn leaf_block_get(&mut self, epoch: Epoch) -> Result<LeafBlock, StorageError>;
     fn high_qc_get(&mut self, epoch: Epoch) -> Result<HighQc, StorageError>;
-    fn transactions_get(&mut self, tx_id: &TransactionId) -> Result<ExecutedTransaction, StorageError>;
+    fn transactions_get(&mut self, tx_id: &TransactionId) -> Result<TransactionRecord, StorageError>;
+    fn transactions_exists(&mut self, tx_id: &TransactionId) -> Result<bool, StorageError>;
     fn transactions_get_any<'a, I: IntoIterator<Item = &'a TransactionId>>(
         &mut self,
         tx_ids: I,
-    ) -> Result<Vec<ExecutedTransaction>, StorageError>;
+    ) -> Result<Vec<TransactionRecord>, StorageError>;
     fn transactions_get_paginated(
         &mut self,
         limit: u64,
         offset: u64,
         asc_desc_created_at: Option<Ordering>,
-    ) -> Result<Vec<ExecutedTransaction>, StorageError>;
+    ) -> Result<Vec<TransactionRecord>, StorageError>;
     fn blocks_get(&mut self, block_id: &BlockId) -> Result<Block, StorageError>;
     fn blocks_get_tip(&mut self, epoch: Epoch) -> Result<Block, StorageError>;
     fn blocks_exists(&mut self, block_id: &BlockId) -> Result<bool, StorageError>;
@@ -155,8 +157,8 @@ pub trait StateStoreWriteTransaction {
     fn high_qc_set(&mut self, high_qc: &HighQc) -> Result<(), StorageError>;
 
     // -------------------------------- Transaction -------------------------------- //
-    fn transactions_insert(&mut self, executed_transaction: &ExecutedTransaction) -> Result<(), StorageError>;
-    fn transactions_update(&mut self, executed_transaction: &ExecutedTransaction) -> Result<(), StorageError>;
+    fn transactions_insert(&mut self, transaction: &Transaction) -> Result<(), StorageError>;
+    fn executed_transactions_update(&mut self, executed_transaction: &ExecutedTransaction) -> Result<(), StorageError>;
     // -------------------------------- Transaction Pool -------------------------------- //
     fn transaction_pool_insert(
         &mut self,
diff --git a/integration_tests/tests/features/claim_burn.feature b/integration_tests/tests/features/claim_burn.feature
index a018122aa..73ae91a2a 100644
--- a/integration_tests/tests/features/claim_burn.feature
+++ b/integration_tests/tests/features/claim_burn.feature
@@ -40,7 +40,6 @@ Feature: Claim Burn
 # Then account ACC has one confidential bucket in it
 
   @serial
-    @doit
   Scenario: Double Claim base layer burn funds with wallet daemon. should fail
     # Initialize a base node, wallet, miner and VN
     Given a base node BASE
diff --git a/integration_tests/tests/features/transfer.feature b/integration_tests/tests/features/transfer.feature
index 2830e7cee..8b49f3ec4 100644
--- a/integration_tests/tests/features/transfer.feature
+++ b/integration_tests/tests/features/transfer.feature
@@ -61,6 +61,8 @@ Feature: Account transfers
 
     # Wait for the wallet daemon account monitor to update the sender account information
 
+    # TODO: remove the wait
+    When I wait 5 seconds
     When I check the balance of ACCOUNT on wallet daemon WALLET_D the amount is at least 1000
     # Do the transfer from ACCOUNT to the second account (which does not exist yet in the network)
     When I create a new key pair KEY_ACC_2
@@ -166,6 +168,8 @@ Feature: Account transfers
     # Initialize the wallet daemon
     Given a wallet daemon WALLET_D connected to indexer IDX
 
+    # TODO: remove the wait
+    When I wait 5 seconds
     # Create the sender account
     When I create an account ACC_1 via the wallet daemon WALLET_D with 1000 free coins
 
diff --git a/integration_tests/tests/features/wallet_daemon.feature b/integration_tests/tests/features/wallet_daemon.feature
index 07c149fb2..8addc5f34 100644
--- a/integration_tests/tests/features/wallet_daemon.feature
+++ b/integration_tests/tests/features/wallet_daemon.feature
@@ -4,6 +4,7 @@
 Feature: Wallet Daemon
 
     @serial
+        @doit
     Scenario: Create account and transfer faucets via wallet daemon
         # Initialize a base node, wallet, miner and VN
         Given a base node BASE
@@ -38,6 +39,8 @@ Feature: Wallet Daemon
         # Create two accounts to test sending the tokens
         When I create an account ACC_1 via the wallet daemon WALLET_D with 1000 free coins
         When I create an account ACC_2 via the wallet daemon WALLET_D
+        # TODO: remove the wait
+        When I wait 3 seconds
         When I check the balance of ACC_2 on wallet daemon WALLET_D the amount is exactly 0
 
         # Create a new Faucet component
@@ -45,6 +48,7 @@ Feature: Wallet Daemon
 
         # Submit a transaction manifest
         When I print the cucumber world
+        # TODO: remove the wait
         When I wait 5 seconds
         When I submit a transaction manifest via wallet daemon WALLET_D with inputs "FAUCET, ACC_1" and 3 outputs named "TX1"
         ```
@@ -70,6 +74,8 @@ Feature: Wallet Daemon
         acc2.balance(faucet_resource);
         acc1.balance(faucet_resource);
         ```
+        # TODO: remove the wait
+        When I wait 5 seconds
         # Check balances
         # Notice that `take_free_coins` extracts precisely 1000 faucet tokens
         When I check the balance of ACC_1 on wallet daemon WALLET_D the amount is at least 1000
@@ -112,6 +118,8 @@ Feature: Wallet Daemon
 
         When I claim burn COMMITMENT with PROOF, RANGEPROOF and CLAIM_PUBKEY and spend it into account ACCOUNT_1 via the wallet daemon WALLET_D
         When I print the cucumber world
+        # TODO: remove the wait
+        When I wait 5 seconds
         When I check the confidential balance of ACCOUNT_1 on wallet daemon WALLET_D the amount is at least 1000
         # When account ACCOUNT_1 reveals 100 burned tokens via wallet daemon WALLET_D
         Then I make a confidential transfer with amount 5 from ACCOUNT_1 to ACCOUNT_2 creating output OUTPUT_TX1 via the wallet_daemon WALLET_D