From d48c8f794358c46e281332cdf018771a78a10c40 Mon Sep 17 00:00:00 2001
From: Stan Bondi <sdbondi@users.noreply.github.com>
Date: Mon, 9 Oct 2023 12:50:24 +0400
Subject: [PATCH] fix(consensus)!: use temporary status updates for blocks >
 locked block (#706)

Description
---
- Creates state updates per block per transaction as blocks are
processed to allow for forks.
- Changes sync protocol to send many smaller messages due to substate
data for full blocks exceeding 4Mb limit in RPC, preventing sync
- Only lock substate objects when a block has been justified (i.e. is a
new leaf block)

Motivation and Context
---
Up to two justified blocks can be forked out. Since we process blocks as
they come in to determine what commands to propose in the next block,
which require state changes, a fork can result in invalid new proposals.
Forks occur in non-malicious cases (stress test) due to high message
volumes which can prevent a node both from sending and receiving
proposal messages before leader timeout, though this is notably improved
after #681 and #693. After leader failure, new proposals with dummy
block parents supersede previously processed blocks. This PR tracks
state changes above the locked block and uses the correct transaction
phases/stages from the locked block and current leaf for new proposals.

Stress testing (up to 1000 transactions in a batch) largely went better
and the chain always continued.
Some issues were encountered when a node fell behind during stress tests
and switched to sync. Some nodes were left with already finalised
transactions in their pool (TBD BUG) and would re-propose them when it
was their turn to be leader. The block would not be voted on and leader
failure would result in the chain continuing. Fixing this bug will be a
focus for subsequent PRs.

How Has This Been Tested?
---
Existing consensus tests, manually with 8 VNs and stress testing,
existing cucumbers

What process can a PR reviewer use to test or verify this change?
---
Run a multi-node network

Breaking Changes
---

- [ ] None
- [x] Requires data directory to be deleted
- [ ] Other - Please specify
---
 .../src/transaction_executor.rs               |   2 +-
 .../src/handlers/rpc.rs                       |   6 +-
 .../tari_signaling_server/src/data.rs         |  10 +-
 .../tari_validator_node/src/bootstrap.rs      |  42 +-
 .../src/comms/deserialize.rs                  |  27 +-
 .../src/consensus/handle.rs                   |  33 +
 .../tari_validator_node/src/consensus/mod.rs  |  36 +-
 .../tari_validator_node/src/dan_node.rs       |   2 +-
 .../src/event_subscription.rs                 |   1 +
 .../src/p2p/rpc/sync_task.rs                  |  58 +-
 .../src/p2p/services/mempool/handle.rs        |  12 -
 .../src/p2p/services/mempool/initializer.rs   |   5 +
 .../src/p2p/services/mempool/service.rs       |  38 +-
 dan_layer/common_types/src/shard_id.rs        |   2 +-
 dan_layer/comms_rpc_state_sync/src/manager.rs |  97 ++-
 dan_layer/consensus/src/hotstuff/common.rs    |   6 +-
 dan_layer/consensus/src/hotstuff/error.rs     |   9 +
 .../consensus/src/hotstuff/on_force_beat.rs   |   2 +-
 .../src/hotstuff/on_next_sync_view.rs         |   4 +-
 .../consensus/src/hotstuff/on_propose.rs      |  10 +-
 .../src/hotstuff/on_receive_new_view.rs       |  72 +-
 .../src/hotstuff/on_receive_proposal.rs       | 703 +++++++++++-------
 .../on_receive_requested_transactions.rs      |   1 +
 .../consensus/src/hotstuff/on_receive_vote.rs |   2 +-
 dan_layer/consensus/src/hotstuff/pacemaker.rs |   2 +-
 .../src/hotstuff/state_machine/mod.rs         |   1 +
 .../src/hotstuff/state_machine/state.rs       |  30 +
 .../src/hotstuff/state_machine/worker.rs      |  13 +-
 dan_layer/consensus/src/hotstuff/worker.rs    |  13 +-
 dan_layer/consensus_tests/src/consensus.rs    |  22 +-
 .../src/support/epoch_manager.rs              |   7 +-
 .../consensus_tests/src/support/harness.rs    |  54 +-
 .../src/support/validator/builder.rs          |   4 +-
 dan_layer/engine/src/transaction/processor.rs |  11 +-
 dan_layer/engine_types/src/commit_result.rs   |  13 +-
 dan_layer/state_store_sqlite/Cargo.toml       |   2 +-
 .../up.sql                                    |  67 +-
 dan_layer/state_store_sqlite/src/reader.rs    | 324 +++++++-
 dan_layer/state_store_sqlite/src/schema.rs    |  30 +-
 .../src/sql_models/transaction_pool.rs        |  70 +-
 dan_layer/state_store_sqlite/src/store.rs     |  10 +
 dan_layer/state_store_sqlite/src/writer.rs    | 213 ++++--
 dan_layer/state_store_sqlite/tests/tests.rs   | 126 +++-
 .../storage/src/consensus_models/block.rs     |  36 +-
 .../storage/src/consensus_models/command.rs   |  25 +-
 .../consensus_models/executed_transaction.rs  |   2 +-
 .../storage/src/consensus_models/high_qc.rs   |  16 +-
 .../src/consensus_models/last_proposed.rs     |   6 +
 .../src/consensus_models/leaf_block.rs        |   2 +-
 .../src/consensus_models/locked_output.rs     |   8 +
 dan_layer/storage/src/consensus_models/mod.rs |   2 +
 .../storage/src/consensus_models/substate.rs  |   8 +
 .../src/consensus_models/transaction.rs       |  29 +-
 .../consensus_models/transaction_decision.rs  |   7 +
 .../src/consensus_models/transaction_pool.rs  | 190 +++--
 .../transaction_pool_status_update.rs         |  48 ++
 dan_layer/storage/src/state_store/mod.rs      |  35 +-
 dan_layer/transaction/src/transaction_id.rs   |   4 +
 dan_layer/validator_node_rpc/proto/rpc.proto  |  18 +-
 .../validator_node_rpc/src/block_sync.rs      |  48 ++
 dan_layer/validator_node_rpc/src/lib.rs       |   2 +
 61 files changed, 2015 insertions(+), 663 deletions(-)
 create mode 100644 applications/tari_validator_node/src/consensus/handle.rs
 create mode 100644 dan_layer/storage/src/consensus_models/transaction_pool_status_update.rs
 create mode 100644 dan_layer/validator_node_rpc/src/block_sync.rs

diff --git a/applications/tari_dan_app_utilities/src/transaction_executor.rs b/applications/tari_dan_app_utilities/src/transaction_executor.rs
index 5d58109f4..0d331ec30 100644
--- a/applications/tari_dan_app_utilities/src/transaction_executor.rs
+++ b/applications/tari_dan_app_utilities/src/transaction_executor.rs
@@ -80,7 +80,7 @@ where TTemplateProvider: TemplateProvider<Template = LoadedTemplate>
         let result = match processor.execute(transaction.clone()) {
             Ok(result) => result,
             Err(err) => ExecuteResult {
-                finalize: FinalizeResult::reject(tx_id, RejectReason::ExecutionFailure(err.to_string())),
+                finalize: FinalizeResult::new_rejectted(tx_id, RejectReason::ExecutionFailure(err.to_string())),
                 transaction_failure: None,
                 fee_receipt: None,
             },
diff --git a/applications/tari_dan_wallet_daemon/src/handlers/rpc.rs b/applications/tari_dan_wallet_daemon/src/handlers/rpc.rs
index 9d9e3817c..d15fea491 100644
--- a/applications/tari_dan_wallet_daemon/src/handlers/rpc.rs
+++ b/applications/tari_dan_wallet_daemon/src/handlers/rpc.rs
@@ -27,7 +27,7 @@ pub async fn handle_discover(
 
 pub async fn handle_login_request(
     context: &HandlerContext,
-    _: Option<String>,
+    _token: Option<String>,
     auth_request: AuthLoginRequest,
 ) -> Result<AuthLoginResponse, anyhow::Error> {
     let jwt = context.wallet_sdk().jwt_api();
@@ -42,7 +42,7 @@ pub async fn handle_login_request(
 
 pub async fn handle_login_accept(
     context: &HandlerContext,
-    _: Option<String>,
+    _token: Option<String>,
     auth_accept_request: AuthLoginAcceptRequest,
 ) -> Result<AuthLoginAcceptResponse, anyhow::Error> {
     let jwt = context.wallet_sdk().jwt_api();
@@ -52,7 +52,7 @@ pub async fn handle_login_accept(
 
 pub async fn handle_login_deny(
     context: &HandlerContext,
-    _: Option<String>,
+    _token: Option<String>,
     auth_deny_request: AuthLoginDenyRequest,
 ) -> Result<AuthLoginDenyResponse, anyhow::Error> {
     let jwt = context.wallet_sdk().jwt_api();
diff --git a/applications/tari_signaling_server/src/data.rs b/applications/tari_signaling_server/src/data.rs
index 5e1ccb8b7..7d782dc78 100644
--- a/applications/tari_signaling_server/src/data.rs
+++ b/applications/tari_signaling_server/src/data.rs
@@ -87,10 +87,7 @@ impl Data {
     }
 
     pub fn add_offer_ice_candidate(&mut self, id: u64, ice_candidate: RTCIceCandidateInit) {
-        self.offer_ice_candidates
-            .entry(id)
-            .or_insert_with(Vec::new)
-            .push(ice_candidate);
+        self.offer_ice_candidates.entry(id).or_default().push(ice_candidate);
     }
 
     pub fn get_offer_ice_candidates(&self, id: u64) -> Result<&Vec<RTCIceCandidateInit>> {
@@ -100,10 +97,7 @@ impl Data {
     }
 
     pub fn add_answer_ice_candidate(&mut self, id: u64, ice_candidate: RTCIceCandidateInit) {
-        self.answer_ice_candidates
-            .entry(id)
-            .or_insert_with(Vec::new)
-            .push(ice_candidate);
+        self.answer_ice_candidates.entry(id).or_default().push(ice_candidate);
     }
 
     pub fn get_answer_ice_candidates(&self, id: u64) -> Result<&Vec<RTCIceCandidateInit>> {
diff --git a/applications/tari_validator_node/src/bootstrap.rs b/applications/tari_validator_node/src/bootstrap.rs
index 89348ca4c..94b4567f0 100644
--- a/applications/tari_validator_node/src/bootstrap.rs
+++ b/applications/tari_validator_node/src/bootstrap.rs
@@ -40,7 +40,6 @@ use tari_common::{
 };
 use tari_common_types::types::PublicKey;
 use tari_comms::{protocol::rpc::RpcServer, types::CommsPublicKey, CommsNode, NodeIdentity, UnspawnedCommsNode};
-use tari_consensus::hotstuff::HotstuffEvent;
 use tari_dan_app_utilities::{
     base_layer_scanner,
     consensus_constants::ConsensusConstants,
@@ -76,8 +75,8 @@ use tokio::{sync::mpsc, task::JoinHandle};
 use crate::{
     comms,
     consensus,
+    consensus::ConsensusHandle,
     dry_run_transaction_processor::DryRunTransactionProcessor,
-    event_subscription::EventSubscription,
     p2p::{
         create_tari_validator_node_rpc_service,
         services::{
@@ -194,9 +193,23 @@ pub async fn spawn_services(
 
     let validator_node_client_factory = TariCommsValidatorNodeClientFactory::new(comms.connectivity());
 
+    // Consensus
+    let (tx_executed_transaction, rx_executed_transaction) = mpsc::channel(10);
+    let (consensus_join_handle, consensus_handle, rx_consensus_to_mempool) = consensus::spawn(
+        state_store.clone(),
+        node_identity.clone(),
+        epoch_manager.clone(),
+        rx_executed_transaction,
+        rx_consensus_message,
+        outbound_messaging.clone(),
+        validator_node_client_factory.clone(),
+        shutdown.clone(),
+    )
+    .await;
+    handles.push(consensus_join_handle);
+
     // Mempool
     let virtual_substate_manager = VirtualSubstateManager::new(state_store.clone(), epoch_manager.clone());
-    let (tx_executed_transaction, rx_executed_transaction) = mpsc::channel(10);
     let scanner = SubstateScanner::new(epoch_manager.clone(), validator_node_client_factory.clone());
     let substate_resolver = TariSubstateResolver::new(
         state_store.clone(),
@@ -206,7 +219,7 @@ pub async fn spawn_services(
     );
     let (mempool, join_handle) = mempool::spawn(
         rx_new_transaction_message,
-        outbound_messaging.clone(),
+        outbound_messaging,
         tx_executed_transaction,
         epoch_manager.clone(),
         node_identity.clone(),
@@ -219,6 +232,8 @@ pub async fn spawn_services(
         ),
         create_mempool_after_execute_validator(state_store.clone()),
         state_store.clone(),
+        rx_consensus_to_mempool,
+        consensus_handle.clone(),
     );
     handles.push(join_handle);
 
@@ -236,21 +251,6 @@ pub async fn spawn_services(
     );
     handles.push(join_handle);
 
-    // Consensus
-    let (consensus_handle, consensus_events) = consensus::spawn(
-        state_store.clone(),
-        node_identity.clone(),
-        epoch_manager.clone(),
-        rx_executed_transaction,
-        rx_consensus_message,
-        outbound_messaging,
-        mempool.clone(),
-        validator_node_client_factory.clone(),
-        shutdown.clone(),
-    )
-    .await;
-    handles.push(consensus_handle);
-
     let comms = setup_p2p_rpc(
         config,
         comms,
@@ -289,7 +289,7 @@ pub async fn spawn_services(
         mempool,
         epoch_manager,
         template_manager: template_manager_service,
-        hotstuff_events: consensus_events,
+        consensus_handle,
         global_db,
         state_store,
         dry_run_transaction_processor,
@@ -321,7 +321,7 @@ pub struct Services {
     pub mempool: MempoolHandle,
     pub epoch_manager: EpochManagerHandle,
     pub template_manager: TemplateManagerHandle,
-    pub hotstuff_events: EventSubscription<HotstuffEvent>,
+    pub consensus_handle: ConsensusHandle,
     pub global_db: GlobalDb<SqliteGlobalDbAdapter>,
     pub dry_run_transaction_processor: DryRunTransactionProcessor,
     pub validator_node_client_factory: TariCommsValidatorNodeClientFactory,
diff --git a/applications/tari_validator_node/src/comms/deserialize.rs b/applications/tari_validator_node/src/comms/deserialize.rs
index c856efe1a..d02438036 100644
--- a/applications/tari_validator_node/src/comms/deserialize.rs
+++ b/applications/tari_validator_node/src/comms/deserialize.rs
@@ -108,17 +108,19 @@ where
             let decoded_msg = proto::network::DanMessage::decode(&mut body)?;
             let message_tag = decoded_msg.message_tag.clone();
             let msg = DanMessage::try_from(decoded_msg)?;
+            let peer = peer_manager
+                .find_by_node_id(&source_peer)
+                .await?
+                .ok_or_else(|| anyhow::anyhow!("Could not find peer with node id {}", source_peer))?;
+
             log::info!(
                 target: LOG_TARGET,
-                "📨 Rx: {} ({} bytes) from {}",
+                "📨 Rx: {} ({} bytes) from {:15}",
                 msg.as_type_str(),
                 body_len,
-                source_peer
+                peer.public_key
             );
-            let peer = peer_manager
-                .find_by_node_id(&source_peer)
-                .await?
-                .ok_or_else(|| anyhow::anyhow!("Could not find peer with node id {}", source_peer))?;
+
             logger.log_inbound_message(peer.public_key.as_bytes(), msg.as_type_str(), &message_tag, &msg);
             let mut svc = next_service.ready_oneshot().await?;
             svc.call((peer.public_key, msg)).await?;
@@ -154,17 +156,18 @@ where
             let body_len = body.len();
             let decoded_msg = proto::consensus::HotStuffMessage::decode(&mut body)?;
             let msg = HotstuffMessage::try_from(decoded_msg)?;
+            let peer = peer_manager
+                .find_by_node_id(&source_peer)
+                .await?
+                .ok_or_else(|| anyhow::anyhow!("Could not find peer with node id {}", source_peer))?;
             log::info!(
                 target: LOG_TARGET,
-                "📨 Rx: {} ({} bytes) from {}",
+                "📨 Rx: {} ({} bytes) from {:15}",
                 msg.as_type_str(),
                 body_len,
-                source_peer
+                peer.public_key
             );
-            let peer = peer_manager
-                .find_by_node_id(&source_peer)
-                .await?
-                .ok_or_else(|| anyhow::anyhow!("Could not find peer with node id {}", source_peer))?;
+
             logger.log_inbound_message(peer.public_key.as_bytes(), msg.as_type_str(), "", &msg);
             let mut svc = next_service.ready_oneshot().await?;
             svc.call((peer.public_key, msg)).await?;
diff --git a/applications/tari_validator_node/src/consensus/handle.rs b/applications/tari_validator_node/src/consensus/handle.rs
new file mode 100644
index 000000000..4e690c2e7
--- /dev/null
+++ b/applications/tari_validator_node/src/consensus/handle.rs
@@ -0,0 +1,33 @@
+//   Copyright 2023 The Tari Project
+//   SPDX-License-Identifier: BSD-3-Clause
+
+use tari_consensus::hotstuff::{ConsensusCurrentState, HotstuffEvent};
+use tokio::sync::{broadcast, watch};
+
+use crate::event_subscription::EventSubscription;
+
+#[derive(Debug, Clone)]
+pub struct ConsensusHandle {
+    rx_current_state: watch::Receiver<ConsensusCurrentState>,
+    events_subscription: EventSubscription<HotstuffEvent>,
+}
+
+impl ConsensusHandle {
+    pub(super) fn new(
+        rx_current_state: watch::Receiver<ConsensusCurrentState>,
+        events_subscription: EventSubscription<HotstuffEvent>,
+    ) -> Self {
+        Self {
+            rx_current_state,
+            events_subscription,
+        }
+    }
+
+    pub fn subscribe_to_hotstuff_events(&mut self) -> broadcast::Receiver<HotstuffEvent> {
+        self.events_subscription.subscribe()
+    }
+
+    pub fn get_current_state(&self) -> ConsensusCurrentState {
+        *self.rx_current_state.borrow()
+    }
+}
diff --git a/applications/tari_validator_node/src/consensus/mod.rs b/applications/tari_validator_node/src/consensus/mod.rs
index df1be0e56..897b30805 100644
--- a/applications/tari_validator_node/src/consensus/mod.rs
+++ b/applications/tari_validator_node/src/consensus/mod.rs
@@ -7,7 +7,7 @@ use tari_common_types::types::PublicKey;
 use tari_comms::{types::CommsPublicKey, NodeIdentity};
 use tari_comms_rpc_state_sync::CommsRpcStateSyncManager;
 use tari_consensus::{
-    hotstuff::{ConsensusWorker, ConsensusWorkerContext, HotstuffEvent, HotstuffWorker},
+    hotstuff::{ConsensusWorker, ConsensusWorkerContext, HotstuffWorker},
     messages::HotstuffMessage,
 };
 use tari_dan_common_types::committee::Committee;
@@ -19,7 +19,7 @@ use tari_state_store_sqlite::SqliteStateStore;
 use tari_transaction::{Transaction, TransactionId};
 use tari_validator_node_rpc::client::TariCommsValidatorNodeClientFactory;
 use tokio::{
-    sync::{broadcast, mpsc},
+    sync::{broadcast, mpsc, watch},
     task::JoinHandle,
 };
 
@@ -31,14 +31,17 @@ use crate::{
         state_manager::TariStateManager,
     },
     event_subscription::EventSubscription,
-    p2p::services::{mempool::MempoolHandle, messaging::OutboundMessaging},
+    p2p::services::messaging::OutboundMessaging,
 };
 
+mod handle;
 mod leader_selection;
 mod signature_service;
 mod spec;
 mod state_manager;
 
+pub use handle::*;
+
 pub async fn spawn(
     store: SqliteStateStore<PublicKey>,
     node_identity: Arc<NodeIdentity>,
@@ -46,10 +49,13 @@ pub async fn spawn(
     rx_new_transactions: mpsc::Receiver<TransactionId>,
     rx_hs_message: mpsc::Receiver<(CommsPublicKey, HotstuffMessage<PublicKey>)>,
     outbound_messaging: OutboundMessaging,
-    mempool: MempoolHandle,
     client_factory: TariCommsValidatorNodeClientFactory,
     shutdown_signal: ShutdownSignal,
-) -> (JoinHandle<Result<(), anyhow::Error>>, EventSubscription<HotstuffEvent>) {
+) -> (
+    JoinHandle<Result<(), anyhow::Error>>,
+    ConsensusHandle,
+    mpsc::UnboundedReceiver<Transaction>,
+) {
     let (tx_broadcast, rx_broadcast) = mpsc::channel(10);
     let (tx_leader, rx_leader) = mpsc::channel(10);
     let (tx_mempool, rx_mempool) = mpsc::unbounded_channel();
@@ -59,7 +65,7 @@ pub async fn spawn(
     let leader_strategy = RoundRobinLeaderStrategy::new();
     let transaction_pool = TransactionPool::new();
     let state_manager = TariStateManager::new();
-    let (tx_events, _) = broadcast::channel(100);
+    let (tx_hotstuff_events, _) = broadcast::channel(100);
 
     let epoch_events = epoch_manager.subscribe().await.unwrap();
 
@@ -75,16 +81,18 @@ pub async fn spawn(
         transaction_pool,
         tx_broadcast,
         tx_leader,
-        tx_events.clone(),
+        tx_hotstuff_events.clone(),
         tx_mempool,
         shutdown_signal.clone(),
     );
 
+    let (tx_current_state, rx_current_state) = watch::channel(Default::default());
     let context = ConsensusWorkerContext {
         epoch_manager: epoch_manager.clone(),
         epoch_events,
         hotstuff: hotstuff_worker,
         state_sync: CommsRpcStateSyncManager::new(epoch_manager, store, client_factory),
+        tx_current_state,
     };
 
     let handle = ConsensusWorker::new(shutdown_signal).spawn(context);
@@ -92,21 +100,21 @@ pub async fn spawn(
     ConsensusMessageWorker {
         rx_broadcast,
         rx_leader,
-        rx_mempool,
         outbound_messaging,
-        mempool,
     }
     .spawn();
 
-    (handle, EventSubscription::new(tx_events))
+    (
+        handle,
+        ConsensusHandle::new(rx_current_state, EventSubscription::new(tx_hotstuff_events)),
+        rx_mempool,
+    )
 }
 
 struct ConsensusMessageWorker {
     rx_broadcast: mpsc::Receiver<(Committee<CommsPublicKey>, HotstuffMessage<CommsPublicKey>)>,
     rx_leader: mpsc::Receiver<(CommsPublicKey, HotstuffMessage<CommsPublicKey>)>,
-    rx_mempool: mpsc::UnboundedReceiver<Transaction>,
     outbound_messaging: OutboundMessaging,
-    mempool: MempoolHandle,
 }
 
 impl ConsensusMessageWorker {
@@ -126,9 +134,7 @@ impl ConsensusMessageWorker {
                             .await
                             .ok();
                     },
-                    Some(tx) = self.rx_mempool.recv() => {
-                        self.mempool.submit_transaction_without_propagating(tx).await.ok();
-                    },
+
                     else => break,
                 }
             }
diff --git a/applications/tari_validator_node/src/dan_node.rs b/applications/tari_validator_node/src/dan_node.rs
index e5586adff..63f8b30e4 100644
--- a/applications/tari_validator_node/src/dan_node.rs
+++ b/applications/tari_validator_node/src/dan_node.rs
@@ -44,7 +44,7 @@ impl DanNode {
     }
 
     pub async fn start(mut self, mut shutdown: ShutdownSignal) -> Result<(), anyhow::Error> {
-        let mut hotstuff_events = self.services.hotstuff_events.subscribe();
+        let mut hotstuff_events = self.services.consensus_handle.subscribe_to_hotstuff_events();
 
         let mut connectivity_events = self.services.comms.connectivity().get_event_subscription();
 
diff --git a/applications/tari_validator_node/src/event_subscription.rs b/applications/tari_validator_node/src/event_subscription.rs
index 2db6bf79d..3aa61c508 100644
--- a/applications/tari_validator_node/src/event_subscription.rs
+++ b/applications/tari_validator_node/src/event_subscription.rs
@@ -27,6 +27,7 @@ use tokio::sync::broadcast;
 ///
 /// We hold a sender because if we held a receiver then the broadcast buffer would always fill up because the receiver
 /// isn't reading off of it.
+#[derive(Debug)]
 pub struct EventSubscription<T>(broadcast::Sender<T>);
 
 impl<T> EventSubscription<T> {
diff --git a/applications/tari_validator_node/src/p2p/rpc/sync_task.rs b/applications/tari_validator_node/src/p2p/rpc/sync_task.rs
index b863dc0dd..7159c4b2c 100644
--- a/applications/tari_validator_node/src/p2p/rpc/sync_task.rs
+++ b/applications/tari_validator_node/src/p2p/rpc/sync_task.rs
@@ -11,14 +11,15 @@ use tari_dan_storage::{
     StateStoreReadTransaction,
     StorageError,
 };
-use tari_validator_node_rpc::proto::rpc::SyncBlocksResponse;
+use tari_validator_node_rpc::proto::rpc::{sync_blocks_response::SyncData, QuorumCertificates, SyncBlocksResponse};
 use tokio::sync::mpsc;
 
 const LOG_TARGET: &str = "tari::dan::rpc::sync_task";
 
 const BLOCK_BUFFER_SIZE: usize = 15;
 
-type BlockBuffer<TAddr> = Vec<(Block<TAddr>, Vec<QuorumCertificate<TAddr>>, Vec<SubstateUpdate<TAddr>>)>;
+type BlockData<TAddr> = (Block<TAddr>, Vec<QuorumCertificate<TAddr>>, Vec<SubstateUpdate<TAddr>>);
+type BlockBuffer<TAddr> = Vec<BlockData<TAddr>>;
 
 pub struct BlockSyncTask<TStateStore: StateStore> {
     store: TStateStore,
@@ -63,13 +64,8 @@ impl<TStateStore: StateStore> BlockSyncTask<TStateStore> {
             );
 
             counter += buffer.len();
-            for (block, quorum_certificates, updates) in buffer.drain(..) {
-                self.send(Ok(SyncBlocksResponse {
-                    block: Some(block.into()),
-                    quorum_certificates: quorum_certificates.iter().map(Into::into).collect(),
-                    substate_updates: updates.into_iter().map(Into::into).collect(),
-                }))
-                .await?;
+            for data in buffer.drain(..) {
+                self.send_block_data(data).await?;
             }
 
             // If we didnt fill up the buffer, send the final blocks
@@ -94,13 +90,8 @@ impl<TStateStore: StateStore> BlockSyncTask<TStateStore> {
             buffer.len(),
         );
 
-        for (block, quorum_certificates, updates) in buffer.drain(..) {
-            self.send(Ok(SyncBlocksResponse {
-                block: Some(block.into()),
-                quorum_certificates: quorum_certificates.iter().map(Into::into).collect(),
-                substate_updates: updates.into_iter().map(Into::into).collect(),
-            }))
-            .await?;
+        for data in buffer.drain(..) {
+            self.send_block_data(data).await?;
         }
 
         Ok(())
@@ -127,6 +118,7 @@ impl<TStateStore: StateStore> BlockSyncTask<TStateStore> {
                     .collect::<HashSet<_>>();
                 let certificates = QuorumCertificate::get_all(tx, all_qcs)?;
                 let updates = child.get_substate_updates(tx)?;
+
                 buffer.push((child, certificates, updates));
                 if buffer.len() == buffer.capacity() {
                     break;
@@ -175,4 +167,38 @@ impl<TStateStore: StateStore> BlockSyncTask<TStateStore> {
         }
         Ok(())
     }
+
+    async fn send_block_data(&mut self, (block, qcs, updates): BlockData<TStateStore::Addr>) -> Result<(), ()> {
+        self.send(Ok(SyncBlocksResponse {
+            sync_data: Some(SyncData::Block(block.into())),
+        }))
+        .await?;
+        self.send(Ok(SyncBlocksResponse {
+            sync_data: Some(SyncData::QuorumCertificates(QuorumCertificates {
+                quorum_certificates: qcs.iter().map(Into::into).collect(),
+            })),
+        }))
+        .await?;
+        match u32::try_from(updates.len()) {
+            Ok(count) => {
+                self.send(Ok(SyncBlocksResponse {
+                    sync_data: Some(SyncData::SubstateCount(count)),
+                }))
+                .await?;
+            },
+            Err(_) => {
+                self.send(Err(RpcStatus::general("number of substates exceeds u32")))
+                    .await?;
+                return Err(());
+            },
+        }
+        for update in updates {
+            self.send(Ok(SyncBlocksResponse {
+                sync_data: Some(SyncData::SubstateUpdate(update.into())),
+            }))
+            .await?;
+        }
+
+        Ok(())
+    }
 }
diff --git a/applications/tari_validator_node/src/p2p/services/mempool/handle.rs b/applications/tari_validator_node/src/p2p/services/mempool/handle.rs
index 9096b4e02..3f312d7ca 100644
--- a/applications/tari_validator_node/src/p2p/services/mempool/handle.rs
+++ b/applications/tari_validator_node/src/p2p/services/mempool/handle.rs
@@ -70,18 +70,6 @@ impl MempoolHandle {
         rx.await?
     }
 
-    pub async fn submit_transaction_without_propagating(&self, transaction: Transaction) -> Result<(), MempoolError> {
-        let (reply, rx) = oneshot::channel();
-        self.tx_mempool_request
-            .send(MempoolRequest::SubmitTransaction {
-                transaction: Box::new(transaction),
-                should_propagate: false,
-                reply,
-            })
-            .await?;
-        rx.await?
-    }
-
     pub async fn remove_transaction(&self, transaction_id: TransactionId) -> Result<(), MempoolError> {
         self.tx_mempool_request
             .send(MempoolRequest::RemoveTransaction { transaction_id })
diff --git a/applications/tari_validator_node/src/p2p/services/mempool/initializer.rs b/applications/tari_validator_node/src/p2p/services/mempool/initializer.rs
index 5d60dc088..27840054d 100644
--- a/applications/tari_validator_node/src/p2p/services/mempool/initializer.rs
+++ b/applications/tari_validator_node/src/p2p/services/mempool/initializer.rs
@@ -33,6 +33,7 @@ use tari_transaction::{Transaction, TransactionId};
 use tokio::{sync::mpsc, task, task::JoinHandle};
 
 use crate::{
+    consensus::ConsensusHandle,
     p2p::services::{
         mempool::{handle::MempoolHandle, service::MempoolService, MempoolError, SubstateResolver, Validator},
         messaging::OutboundMessaging,
@@ -51,6 +52,8 @@ pub fn spawn<TExecutor, TValidator, TExecutedValidator, TSubstateResolver>(
     validator: TValidator,
     after_executed_validator: TExecutedValidator,
     state_store: SqliteStateStore<PublicKey>,
+    rx_consensus_to_mempool: mpsc::UnboundedReceiver<Transaction>,
+    consensus_handle: ConsensusHandle,
 ) -> (MempoolHandle, JoinHandle<anyhow::Result<()>>)
 where
     TValidator: Validator<Transaction, Error = MempoolError> + Send + Sync + 'static,
@@ -72,6 +75,8 @@ where
         validator,
         after_executed_validator,
         state_store,
+        rx_consensus_to_mempool,
+        consensus_handle,
     );
     let handle = MempoolHandle::new(tx_mempool_request);
 
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 4c349fec0..4bca87859 100644
--- a/applications/tari_validator_node/src/p2p/services/mempool/service.rs
+++ b/applications/tari_validator_node/src/p2p/services/mempool/service.rs
@@ -40,6 +40,7 @@ use tokio::sync::{mpsc, oneshot};
 
 use super::MempoolError;
 use crate::{
+    consensus::ConsensusHandle,
     p2p::services::{
         mempool::{
             executor::{execute_transaction, ExecutionResult},
@@ -77,6 +78,8 @@ pub struct MempoolService<TValidator, TExecutedValidator, TExecutor, TSubstateRe
     state_store: SqliteStateStore<PublicKey>,
     transaction_pool: TransactionPool<SqliteStateStore<PublicKey>>,
     gossip: Gossip,
+    rx_consensus_to_mempool: mpsc::UnboundedReceiver<Transaction>,
+    consensus_handle: ConsensusHandle,
 }
 
 impl<TValidator, TExecutedValidator, TExecutor, TSubstateResolver>
@@ -99,6 +102,8 @@ where
         before_execute_validator: TValidator,
         after_execute_validator: TExecutedValidator,
         state_store: SqliteStateStore<PublicKey>,
+        rx_consensus_to_mempool: mpsc::UnboundedReceiver<Transaction>,
+        consensus_handle: ConsensusHandle,
     ) -> Self {
         Self {
             gossip: Gossip::new(epoch_manager.clone(), outbound, node_identity.public_key().clone()),
@@ -114,6 +119,8 @@ where
             after_execute_validator,
             state_store,
             transaction_pool: TransactionPool::new(),
+            rx_consensus_to_mempool,
+            consensus_handle,
         }
     }
 
@@ -131,6 +138,11 @@ where
                         warn!(target: LOG_TARGET, "Mempool rejected transaction: {}", e);
                     }
                 }
+                Some(msg) = self.rx_consensus_to_mempool.recv() => {
+                    if let Err(e) = self.handle_new_transaction_from_local(msg, false).await {
+                        warn!(target: LOG_TARGET, "Mempool rejected transaction: {}", e);
+                    }
+                }
 
                 else => {
                     info!(target: LOG_TARGET, "Mempool service shutting down");
@@ -198,6 +210,15 @@ where
             output_shards: unverified_output_shards,
         } = msg;
 
+        if !self.consensus_handle.get_current_state().is_running() {
+            info!(
+                target: LOG_TARGET,
+                "🎱 Transaction {} received while not in running state. Ignoring",
+                transaction.id()
+            );
+            return Ok(());
+        }
+
         if self.transaction_exists(transaction.id())? {
             return Ok(());
         }
@@ -416,6 +437,8 @@ where
         // This is due to a bug or possibly db failure only
         let (transaction_id, exec_result) = result?;
 
+        let is_consensus_running = self.consensus_handle.get_current_state().is_running();
+
         let executed = match exec_result {
             Ok(mut executed) => {
                 info!(
@@ -432,7 +455,10 @@ where
                         // either are awaiting execution OR execution is complete and it's in the pool.
                         self.state_store.with_write_tx(|tx| {
                             executed.update(tx)?;
-                            self.transaction_pool.insert(tx, executed.to_atom())
+                            if is_consensus_running {
+                                self.transaction_pool.insert(tx, executed.to_atom())?;
+                            }
+                            Ok::<_, MempoolError>(())
                         })?;
                     },
                     Err(e) => {
@@ -440,7 +466,10 @@ where
                             executed
                                 .set_abort(format!("Mempool after execution validation failed: {}", e))
                                 .update(tx)?;
-                            self.transaction_pool.insert(tx, executed.to_atom())
+                            if is_consensus_running {
+                                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
                         // outputs already exist) so we need to send LocalPrepared(ABORT) to
@@ -458,8 +487,7 @@ where
                     e
                 );
                 self.state_store.with_write_tx(|tx| {
-                    let mut transaction = TransactionRecord::get(tx.deref_mut(), &transaction_id)?;
-                    transaction
+                    TransactionRecord::get(tx.deref_mut(), &transaction_id)?
                         .set_abort(format!("Mempool failed to execute: {}", e))
                         .update(tx)
                 })?;
@@ -509,7 +537,7 @@ where
         }
 
         // Notify consensus that a transaction is ready to go!
-        if self.tx_executed_transactions.send(*executed.id()).await.is_err() {
+        if is_consensus_running && self.tx_executed_transactions.send(*executed.id()).await.is_err() {
             debug!(
                 target: LOG_TARGET,
                 "Executed transaction channel closed before executed transaction could be sent"
diff --git a/dan_layer/common_types/src/shard_id.rs b/dan_layer/common_types/src/shard_id.rs
index f583a44d2..97fca2f9a 100644
--- a/dan_layer/common_types/src/shard_id.rs
+++ b/dan_layer/common_types/src/shard_id.rs
@@ -126,7 +126,7 @@ impl AsRef<[u8]> for ShardId {
 
 impl PartialOrd for ShardId {
     fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-        self.0.partial_cmp(&other.0)
+        Some(self.cmp(other))
     }
 }
 
diff --git a/dan_layer/comms_rpc_state_sync/src/manager.rs b/dan_layer/comms_rpc_state_sync/src/manager.rs
index 4ff9ff500..9217ece23 100644
--- a/dan_layer/comms_rpc_state_sync/src/manager.rs
+++ b/dan_layer/comms_rpc_state_sync/src/manager.rs
@@ -33,6 +33,8 @@ use crate::error::CommsRpcConsensusSyncError;
 
 const LOG_TARGET: &str = "tari::dan::comms_rpc_state_sync";
 
+const MAX_SUBSTATE_UPDATES: usize = 10000;
+
 pub struct CommsRpcStateSyncManager<TEpochManager, TStateStore> {
     epoch_manager: TEpochManager,
     state_store: TStateStore,
@@ -119,37 +121,79 @@ where
 
         while let Some(resp) = stream.next().await {
             let msg = resp.map_err(RpcError::from)?;
-            let block = msg
-                .block
-                .map(Block::<CommsPublicKey>::try_from)
-                .transpose()
-                .map_err(CommsRpcConsensusSyncError::InvalidResponse)?
-                .ok_or_else(|| {
-                    CommsRpcConsensusSyncError::InvalidResponse(anyhow::anyhow!(
-                        "Peer returned an empty block response"
-                    ))
-                })?;
-            // if block.height() != expected_height {
+            let new_block = msg.into_block().ok_or_else(|| {
+                CommsRpcConsensusSyncError::InvalidResponse(anyhow::anyhow!("Expected peer to return a newblock",))
+            })?;
+
+            // if block.height != expected_height {
             //     return Err(CommsRpcConsensusSyncError::InvalidResponse(anyhow::anyhow!(
             //         "Peer returned block at height {} but expected {}",
             //         block.height(),
             //         expected_height,
             //     )));
             // }
-            let qcs = msg
-                .quorum_certificates
+
+            let block =
+                Block::<CommsPublicKey>::try_from(new_block).map_err(CommsRpcConsensusSyncError::InvalidResponse)?;
+
+            debug!(target: LOG_TARGET, "🌐 Received block {}", block);
+
+            let Some(resp) = stream.next().await else {
+                return Err(CommsRpcConsensusSyncError::InvalidResponse(anyhow::anyhow!(
+                    "Peer closed session before sending QC message"
+                )));
+            };
+            let msg = resp.map_err(RpcError::from)?;
+            let qcs = msg.into_quorum_certificates().ok_or_else(|| {
+                CommsRpcConsensusSyncError::InvalidResponse(anyhow::anyhow!("Expected peer to return QCs"))
+            })?;
+
+            debug!(target: LOG_TARGET, "🌐 Received block {}, {} qcs", block, qcs.len());
+
+            let qcs = qcs
                 .into_iter()
                 .map(QuorumCertificate::<CommsPublicKey>::try_from)
                 .collect::<Result<Vec<_>, _>>()
                 .map_err(CommsRpcConsensusSyncError::InvalidResponse)?;
-            let updates = msg
-                .substate_updates
-                .into_iter()
-                .map(SubstateUpdate::try_from)
-                .collect::<Result<Vec<_>, _>>()
-                .map_err(CommsRpcConsensusSyncError::InvalidResponse)?;
 
             // TODO: Validate
+
+            let Some(resp) = stream.next().await else {
+                return Err(CommsRpcConsensusSyncError::InvalidResponse(anyhow::anyhow!(
+                    "Peer closed session before sending substate update count message"
+                )));
+            };
+            let msg = resp.map_err(RpcError::from)?;
+            let num_substates = msg.substate_count().ok_or_else(|| {
+                CommsRpcConsensusSyncError::InvalidResponse(anyhow::anyhow!("Expected peer to return substate count",))
+            })? as usize;
+
+            if num_substates > MAX_SUBSTATE_UPDATES {
+                return Err(CommsRpcConsensusSyncError::InvalidResponse(anyhow::anyhow!(
+                    "Peer returned {} substate updates, but the maximum is {}",
+                    num_substates,
+                    MAX_SUBSTATE_UPDATES,
+                )));
+            }
+
+            let mut updates = Vec::with_capacity(num_substates);
+            for _ in 0..num_substates {
+                let Some(resp) = stream.next().await else {
+                    return Err(CommsRpcConsensusSyncError::InvalidResponse(anyhow::anyhow!(
+                        "Peer closed session before sending substate updates message"
+                    )));
+                };
+                let msg = resp.map_err(RpcError::from)?;
+                let update = msg.into_substate_update().ok_or_else(|| {
+                    CommsRpcConsensusSyncError::InvalidResponse(anyhow::anyhow!(
+                        "Expected peer to return substate updates",
+                    ))
+                })?;
+
+                let update = SubstateUpdate::try_from(update).map_err(CommsRpcConsensusSyncError::InvalidResponse)?;
+                updates.push(update);
+            }
+
             debug!(
                 target: LOG_TARGET,
                 "🌐 Received block {}, {} qcs and {} substate updates",
@@ -162,7 +206,7 @@ where
                 info!(target: LOG_TARGET, "🌐 Syncing block {block}");
             }
             // expected_height += NodeHeight(1);
-            self.commit_block(block, qcs, updates)?;
+            self.process_block(block, qcs, updates)?;
         }
 
         info!(target: LOG_TARGET, "🌐 {} blocks synced", counter);
@@ -170,7 +214,7 @@ where
         Ok(())
     }
 
-    fn commit_block(
+    fn process_block(
         &self,
         block: Block<CommsPublicKey>,
         qcs: Vec<QuorumCertificate<CommsPublicKey>>,
@@ -182,7 +226,11 @@ where
             }
 
             block.justify().save(tx)?;
-            block.save(tx)?;
+            if !block.save(tx)? {
+                // We've already seen this block. This could happen because we're syncing from high qc and we receive a
+                // block that we already have
+                return Ok(());
+            }
             for qc in qcs {
                 qc.save(tx)?;
             }
@@ -193,15 +241,18 @@ where
                     let new_last_exec = block.as_last_executed();
                     Self::mark_block_committed(tx, last_executed, block)?;
                     new_last_exec.set(tx)?;
+
                     TransactionPoolRecord::remove_any(
                         tx,
-                        block.commands().iter().filter_map(|cmd| cmd.accept()).map(|t| t.id),
+                        block.commands().iter().filter_map(|cmd| cmd.accept()).map(|t| &t.id),
                     )?;
+
                     Ok::<_, CommsRpcConsensusSyncError>(())
                 },
             )?;
             let (ups, downs) = updates.into_iter().partition::<Vec<_>, _>(|u| u.is_create());
             // First do UPs then do DOWNs
+            // TODO: stage the updates, then check against the state hash in the block, then persist
             for update in ups {
                 update.apply(tx, &block)?;
             }
diff --git a/dan_layer/consensus/src/hotstuff/common.rs b/dan_layer/consensus/src/hotstuff/common.rs
index 548808ac6..41facf492 100644
--- a/dan_layer/consensus/src/hotstuff/common.rs
+++ b/dan_layer/consensus/src/hotstuff/common.rs
@@ -7,7 +7,7 @@ use tari_dan_storage::consensus_models::{Block, QuorumCertificate, QuorumDecisio
 
 use crate::{messages::HotstuffMessage, traits::LeaderStrategy};
 
-const LOG_TARGET: &str = "tari::dan::consensus::hotstuff";
+const LOG_TARGET: &str = "tari::dan::consensus::hotstuff::common";
 
 /// The value that fees are divided by to determine the amount of fees to burn. 0 means no fees are burned.
 /// This is a placeholder for the fee exhaust consensus constant so that we know where it's used later.
@@ -35,9 +35,7 @@ pub fn calculate_dummy_blocks<TAddr: NodeAddressable, TLeaderStrategy: LeaderStr
         );
         return Vec::new();
     }
-    if current_height == new_height {
-        return Vec::new();
-    }
+
     debug!(
         target: LOG_TARGET,
         "🍼 calculating dummy blocks from {} to {}",
diff --git a/dan_layer/consensus/src/hotstuff/error.rs b/dan_layer/consensus/src/hotstuff/error.rs
index 159f5cab2..a79ca1cac 100644
--- a/dan_layer/consensus/src/hotstuff/error.rs
+++ b/dan_layer/consensus/src/hotstuff/error.rs
@@ -42,6 +42,15 @@ pub enum HotStuffError {
     TransactionPoolError(#[from] TransactionPoolError),
     #[error("Transaction {transaction_id} does not exist")]
     TransactionDoesNotExist { transaction_id: TransactionId },
+    #[error(
+        "Unable execute block {block_id} because the committee decided to ACCEPT transaction {transaction_id} but it \
+         failed to execute locally: {reject_reason}"
+    )]
+    RejectedTransactionCommitDecision {
+        block_id: BlockId,
+        transaction_id: TransactionId,
+        reject_reason: String,
+    },
     #[error("Pacemaker channel dropped: {details}")]
     PacemakerChannelDropped { details: String },
     #[error(
diff --git a/dan_layer/consensus/src/hotstuff/on_force_beat.rs b/dan_layer/consensus/src/hotstuff/on_force_beat.rs
index c2a9ed9e7..5ae8efbe5 100644
--- a/dan_layer/consensus/src/hotstuff/on_force_beat.rs
+++ b/dan_layer/consensus/src/hotstuff/on_force_beat.rs
@@ -23,7 +23,7 @@ impl OnForceBeat {
 
     pub async fn wait(&mut self) -> Option<LeafBlock> {
         self.receiver.changed().await.expect("sender can never be dropped");
-        self.receiver.borrow().clone()
+        *self.receiver.borrow()
     }
 
     pub fn beat(&self, parent_block: Option<LeafBlock>) {
diff --git a/dan_layer/consensus/src/hotstuff/on_next_sync_view.rs b/dan_layer/consensus/src/hotstuff/on_next_sync_view.rs
index 4f3b5f811..a73bb5130 100644
--- a/dan_layer/consensus/src/hotstuff/on_next_sync_view.rs
+++ b/dan_layer/consensus/src/hotstuff/on_next_sync_view.rs
@@ -50,14 +50,14 @@ impl<TConsensusSpec: ConsensusSpec> OnNextSyncViewHandler<TConsensusSpec> {
             .leader_strategy
             .get_leader_for_next_block(&local_committee, new_height);
 
+        info!(target: LOG_TARGET, "🌟 Send NEWVIEW {new_height} HighQC: {} to {next_leader}", high_qc);
+
         let message = NewViewMessage {
             high_qc,
             new_height,
             epoch: current_epoch,
         };
 
-        info!(target: LOG_TARGET, "🔥 Send NEWVIEW {new_height} to {next_leader}");
-
         self.tx_leader
             .send((next_leader.clone(), HotstuffMessage::NewView(message)))
             .await
diff --git a/dan_layer/consensus/src/hotstuff/on_propose.rs b/dan_layer/consensus/src/hotstuff/on_propose.rs
index ef90056e7..4f82086bc 100644
--- a/dan_layer/consensus/src/hotstuff/on_propose.rs
+++ b/dan_layer/consensus/src/hotstuff/on_propose.rs
@@ -104,9 +104,17 @@ where TConsensusSpec: ConsensusSpec
                         );
                         self.broadcast_proposal(epoch, next_block, non_local_buckets, local_committee)
                             .await?;
+                        return Ok(());
                     }
                 }
 
+                debug!(
+                    target: LOG_TARGET,
+                    "⤵️ SKIPPING propose for leaf {} because we already proposed block {}",
+                    leaf_block,
+                    last_proposed,
+                );
+
                 return Ok(());
             }
         }
@@ -225,7 +233,7 @@ where TConsensusSpec: ConsensusSpec
         let batch = if empty_block {
             vec![]
         } else {
-            self.transaction_pool.get_batch(tx, TARGET_BLOCK_SIZE)?
+            self.transaction_pool.get_batch_for_next_block(tx, TARGET_BLOCK_SIZE)?
         };
 
         let mut total_leader_fee = 0;
diff --git a/dan_layer/consensus/src/hotstuff/on_receive_new_view.rs b/dan_layer/consensus/src/hotstuff/on_receive_new_view.rs
index 2a7892836..afe697ea2 100644
--- a/dan_layer/consensus/src/hotstuff/on_receive_new_view.rs
+++ b/dan_layer/consensus/src/hotstuff/on_receive_new_view.rs
@@ -1,7 +1,10 @@
 //   Copyright 2023 The Tari Project
 //   SPDX-License-Identifier: BSD-3-Clause
 
-use std::collections::{HashMap, HashSet};
+use std::{
+    collections::{HashMap, HashSet},
+    ops::DerefMut,
+};
 
 use log::*;
 use tari_dan_common_types::NodeHeight;
@@ -54,6 +57,20 @@ where TConsensusSpec: ConsensusSpec
         self.newview_message_counts.clear();
     }
 
+    fn collect_new_views(
+        &mut self,
+        from: &TConsensusSpec::Addr,
+        new_height: NodeHeight,
+        high_qc: &QuorumCertificate<TConsensusSpec::Addr>,
+    ) -> usize {
+        let entry = self
+            .newview_message_counts
+            .entry((new_height, *high_qc.block_id()))
+            .or_default();
+        entry.insert(from.clone());
+        entry.len()
+    }
+
     #[allow(clippy::too_many_lines)]
     pub async fn handle(
         &mut self,
@@ -67,7 +84,7 @@ where TConsensusSpec: ConsensusSpec
         } = message;
         debug!(
             target: LOG_TARGET,
-            "🔥 Received NEWVIEW for qc {} new height {} from {}",
+            "🌟 Received NEWVIEW for qc {} new height {} from {}",
             high_qc.id(),
             new_height,
             from
@@ -99,17 +116,10 @@ where TConsensusSpec: ConsensusSpec
 
         self.validate_qc(&high_qc)?;
 
-        let checked_high_qc = self.store.with_write_tx(|tx| high_qc.update_high_qc(tx))?;
-
-        if checked_high_qc.block_height() > high_qc.block_height() {
-            warn!(target: LOG_TARGET, "❌ Ignoring NEWVIEW for because high QC is not higher than previous high QC, given high QC: {} current high QC: {}", high_qc.as_high_qc(), checked_high_qc);
-            return Ok(());
-        }
-
         // Sync if we do not have the block for this valid QC
         let exists = self
             .store
-            .with_read_tx(|tx| Block::record_exists(tx, checked_high_qc.block_id()))?;
+            .with_read_tx(|tx| Block::record_exists(tx, high_qc.block_id()))?;
         if !exists {
             return Err(HotStuffError::ProposalValidationError(
                 ProposalValidationError::JustifyBlockNotFound {
@@ -120,13 +130,6 @@ where TConsensusSpec: ConsensusSpec
             ));
         }
 
-        // Clear our NEWVIEWs for previous views
-        self.newview_message_counts = self
-            .newview_message_counts
-            .drain()
-            .filter(|((h, _), _)| *h >= checked_high_qc.block_height())
-            .collect();
-
         let local_committee = self.epoch_manager.get_local_committee(epoch).await?;
         let leader = self
             .leader_strategy
@@ -153,23 +156,32 @@ where TConsensusSpec: ConsensusSpec
         }
 
         // Take note of unique NEWVIEWs so that we can count them
-        let collected_new_views = self
-            .newview_message_counts
-            .entry((new_height, *high_qc.block_id()))
-            .or_default();
-        collected_new_views.insert(from.clone());
+        let newview_count = self.collect_new_views(&from, new_height, &high_qc);
+
+        let high_qc = self.store.with_write_tx(|tx| {
+            let high_qc = high_qc.update_high_qc(tx)?;
+            high_qc.get_quorum_certificate(tx.deref_mut())
+        })?;
+
+        // if checked_high_qc.block_height() > high_qc.block_height() {
+        //     warn!(target: LOG_TARGET, "❌ Ignoring NEWVIEW for because high QC is not higher than previous high QC,
+        // given high QC: {} current high QC: {}", high_qc.as_high_qc(), checked_high_qc);     return Ok(());
+        // }
+
         let threshold = self.epoch_manager.get_local_threshold_for_epoch(epoch).await?;
+
         info!(
             target: LOG_TARGET,
-            "🌟 Received NEWVIEW for block {} has {} votes out of {}",
+            "🌟 Received NEWVIEW for height {} (QC: {}) has {} votes out of {}",
             new_height,
-            collected_new_views.len(),
-            threshold
+            high_qc,
+            newview_count,
+            threshold,
         );
         // Once we have received enough (quorum) NEWVIEWS, we can create the dummy block(s) and propose the next block.
         // Any subsequent NEWVIEWs for this height/view are ignored.
-        if collected_new_views.len() == threshold {
-            info!(target: LOG_TARGET, "🌟✅ NEWVIEW for block {} (high_qc: {}) has reached quorum", new_height, high_qc.as_high_qc());
+        if newview_count == threshold {
+            info!(target: LOG_TARGET, "🌟✅ NEWVIEW for block {} (high_qc: {}) has reached quorum ({}/{})", new_height, high_qc.as_high_qc(), newview_count, threshold);
 
             // Determine how many missing blocks we must fill without actually creating them.
             // This node, as well as all other replicas, will create the blocks in on_receive_proposal.
@@ -188,6 +200,12 @@ where TConsensusSpec: ConsensusSpec
             debug!(target: LOG_TARGET, "🍼 dummy leaf block {}", parent_block);
             // Force beat so that a block is proposed even if there are no transactions
             self.pacemaker.force_beat(parent_block);
+            // Clear our NEWVIEWs for previous views
+            self.newview_message_counts = self
+                .newview_message_counts
+                .drain()
+                .filter(|((h, _), _)| *h >= high_qc.block_height())
+                .collect();
         }
 
         Ok(())
diff --git a/dan_layer/consensus/src/hotstuff/on_receive_proposal.rs b/dan_layer/consensus/src/hotstuff/on_receive_proposal.rs
index 07098535f..7bd777994 100644
--- a/dan_layer/consensus/src/hotstuff/on_receive_proposal.rs
+++ b/dan_layer/consensus/src/hotstuff/on_receive_proposal.rs
@@ -12,6 +12,7 @@ use tari_dan_common_types::{
     committee::{Committee, CommitteeShard},
     optional::Optional,
     NodeHeight,
+    ShardId,
 };
 use tari_dan_storage::{
     consensus_models::{
@@ -23,13 +24,13 @@ use tari_dan_storage::{
         HighQc,
         LastExecuted,
         LastVoted,
+        LeafBlock,
         LockedBlock,
         LockedOutput,
         QuorumDecision,
         SubstateLockFlag,
         SubstateRecord,
         TransactionPool,
-        TransactionPoolRecord,
         TransactionPoolStage,
         TransactionRecord,
     },
@@ -152,7 +153,7 @@ where TConsensusSpec: ConsensusSpec
                     },
                     HotStuffError::ProposalValidationError(err) => {
                         warn!(target: LOG_TARGET, "❌ Block failed validation: {}", err);
-                        // A bad block should not disrupt consensus
+                        // A bad block should not cause a FAILURE state transition
                         tx.rollback()?;
                         return Ok(());
                     },
@@ -165,11 +166,13 @@ where TConsensusSpec: ConsensusSpec
             // Now that we have all dummy blocks (if any) in place, we can check if the candidate block is safe.
             // Specifically, it should extend the locked block via the dummy blocks.
             if !block.is_safe(tx.deref_mut())? {
-                return Err(ProposalValidationError::NotSafeBlock {
+                tx.rollback()?;
+                let err = ProposalValidationError::NotSafeBlock {
                     proposed_by: from.to_string(),
                     hash: *block.id(),
-                }
-                .into());
+                };
+                warn!(target: LOG_TARGET, "❌ Block failed validation: {}", err);
+                return Ok(());
             }
 
             // Insert the block if it doesnt already exist
@@ -181,11 +184,13 @@ where TConsensusSpec: ConsensusSpec
                 );
             }
 
-            let missing_tuple = self.block_get_missing_transaction(&mut tx, &block)?;
+            let missing_tuple = self.handle_missing_transaction(&mut tx, &block)?;
             tx.commit()?;
             missing_tuple
         };
 
+        let high_qc = self.store.with_read_tx(|tx| HighQc::get(tx))?;
+
         if !missing_tx_ids.is_empty() {
             self.send_to_leader(
                 &local_committee,
@@ -196,12 +201,16 @@ where TConsensusSpec: ConsensusSpec
                     transactions: missing_tx_ids,
                 }),
             )
-            .await?;
+            .await;
+            self.pacemaker
+                .reset_leader_timeout(block.height(), high_qc.block_height())
+                .await?;
             return Ok(());
         }
 
         if awaiting_execution.is_empty() {
-            if let Some(vote) = self.process_block(&local_committee_shard, &block).await? {
+            if let Some(decision) = self.decide_on_block(&local_committee_shard, &block)? {
+                let vote = self.generate_vote_message(&block, decision).await?;
                 let high_qc = self.store.with_write_tx(|tx| {
                     block.as_last_voted().set(tx)?;
                     HighQc::get(tx.deref_mut())
@@ -209,14 +218,18 @@ where TConsensusSpec: ConsensusSpec
                 self.pacemaker
                     .reset_leader_timeout(block.height(), high_qc.block_height())
                     .await?;
-                self.send_vote_to_leader(&local_committee, vote, block.height()).await?;
+                self.send_vote_to_leader(&local_committee, vote, &block).await;
             }
+        } else {
+            self.pacemaker
+                .reset_leader_timeout(block.height(), high_qc.block_height())
+                .await?;
         }
 
         Ok(())
     }
 
-    fn block_get_missing_transaction(
+    fn handle_missing_transaction(
         &self,
         tx: &mut <TConsensusSpec::StateStore as StateStore>::WriteTransaction<'_>,
         block: &Block<TConsensusSpec::Addr>,
@@ -229,6 +242,10 @@ where TConsensusSpec: ConsensusSpec
             .collect::<HashSet<_>>();
 
         if missing_tx_ids.is_empty() && awaiting_execution.is_empty() {
+            debug!(
+                target: LOG_TARGET,
+                "✅ Block {} has no missing transactions", block
+            );
             return Ok((HashSet::new(), HashSet::new()));
         }
 
@@ -261,52 +278,131 @@ where TConsensusSpec: ConsensusSpec
         Ok(())
     }
 
-    async fn process_block(
+    fn decide_on_block(
         &self,
         local_committee_shard: &CommitteeShard,
         block: &Block<TConsensusSpec::Addr>,
-    ) -> Result<Option<VoteMessage<TConsensusSpec::Addr>>, HotStuffError> {
-        let mut maybe_decision = None;
-        {
-            let mut tx = self.store.create_write_tx()?;
-            let should_vote = self.should_vote(tx.deref_mut(), block)?;
-            let mut abort_transactions = Vec::new();
-            if should_vote {
-                (maybe_decision, abort_transactions) =
-                    self.decide_what_to_vote(&mut tx, block, local_committee_shard)?;
+    ) -> Result<Option<QuorumDecision>, HotStuffError> {
+        self.store.with_write_tx(|tx| {
+            let mut decision = BlockDecision::vote_accept();
+            if self.should_vote(tx.deref_mut(), block)? {
+                decision = self.decide_what_to_vote(tx, block, local_committee_shard)?;
+            } else {
+                decision.dont_vote();
             }
 
-            if maybe_decision.is_some() {
-                block.update_nodes(
-                    &mut tx,
-                    |tx, _, block| self.on_lock_block(tx, block),
+            if decision.is_accept() {
+                let high_qc = block.update_nodes(
+                    tx,
+                    |tx, locked, block| self.on_lock_block(tx, locked, block),
                     |tx, last_exec, commit_block| self.on_commit(tx, last_exec, commit_block, local_committee_shard),
                 )?;
 
-                tx.commit()?;
-            } else {
-                tx.rollback()?;
-                debug!(
-                    target: LOG_TARGET,
-                    "❌ ROLLBACK block {}. {} aborted transaction(s)", block, abort_transactions.len(),
-                );
-                if !abort_transactions.is_empty() {
-                    self.store.with_write_tx(|tx| {
-                        for mut tx_rec in abort_transactions {
-                            tx_rec.update_local_decision(tx, Decision::Abort)?;
-                        }
-                        Ok::<_, HotStuffError>(())
-                    })?;
-                }
+                // If we have a new high QC, we'll process the block it justifies
+                self.process_new_leaf(tx, high_qc, block, local_committee_shard)?;
             }
-        };
 
-        let mut maybe_vote = None;
-        if let Some(decision) = maybe_decision {
-            maybe_vote = Some(self.generate_vote_message(block, decision).await?);
+            Ok::<_, HotStuffError>(decision.as_quorum_decision())
+        })
+    }
+
+    fn process_new_leaf(
+        &self,
+        tx: &mut <TConsensusSpec::StateStore as StateStore>::WriteTransaction<'_>,
+        high_qc: HighQc,
+        tip_block: &Block<TConsensusSpec::Addr>,
+        local_committee_shard: &CommitteeShard,
+    ) -> Result<(), HotStuffError> {
+        let leaf = high_qc.get_block(tx.deref_mut())?;
+        if leaf.is_processed() {
+            return Ok(());
         }
 
-        Ok(maybe_vote)
+        for cmd in leaf.commands() {
+            match cmd {
+                Command::Prepare(t) => {
+                    let mut tx_rec = self.transaction_pool.get(tx, tip_block.as_leaf_block(), t.id())?;
+
+                    if t.decision.is_commit() {
+                        let transaction = ExecutedTransaction::get(tx.deref_mut(), cmd.transaction_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_outputs_locked = is_inputs_locked && self.lock_outputs(tx, leaf.id(), &transaction)?;
+
+                        if !is_inputs_locked {
+                            // Unable to lock all inputs - do not vote
+                            warn!(
+                                target: LOG_TARGET,
+                                "❌ Unable to lock all inputs for transaction {} in block {}. Leader proposed {}, we decided {}",
+                                leaf.id(),
+                                transaction.id(),
+                                t.decision,
+                                Decision::Abort
+                            );
+                            // We change our decision to ABORT so that the next time we propose/receive a
+                            // proposal we will check for ABORT. It may
+                            // happen that the transaction causing the lock failure
+                            // is ABORTED too and the locks released allowing this transaction to succeed.
+                            // Currently, the client would have to resubmit the transaction to resolve this.
+                            tx_rec.update_local_decision(tx, Decision::Abort)?;
+
+                            // The leader should not have proposed conflicting transactions
+                        } else if !is_outputs_locked {
+                            // Unable to lock all outputs - do not vote
+                            warn!(
+                                target: LOG_TARGET,
+                                "❌ Unable to lock all outputs for transaction {} in block {}. Leader proposed {}, we decided {}",
+                                leaf.id(),
+                                transaction.id(),
+                                t.decision,
+                                Decision::Abort
+                            );
+                            // Unlock any locked inputs because we are not voting
+                            self.unlock_inputs(tx, transaction.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
+                            tx_rec.update_local_decision(tx, Decision::Abort)?;
+                        } else {
+                            // We have locked all inputs and outputs
+                        }
+                    }
+                },
+                Command::LocalPrepared(t) => {
+                    let mut tx_rec = self.transaction_pool.get(tx, tip_block.as_leaf_block(), t.id())?;
+
+                    debug!(
+                        target: LOG_TARGET,
+                        "🔥 Process NEW leaf block: Update local proposal for transaction: {}. Local stage: {}, Leaf: {}",
+                        tx_rec.transaction_id(),
+                        tx_rec.current_stage(),
+                        leaf,
+                    );
+
+                    // If all shards are complete and we've already received our LocalPrepared, we can set the
+                    // LocalPrepared transaction as ready to propose ACCEPT.
+                    if tx_rec.current_stage().is_local_prepared() && tx_rec.transaction().evidence.all_shards_complete()
+                    {
+                        info!(
+                            target: LOG_TARGET,
+                            "🔥 Process NEW leaf block: Transaction is ready for propose ACCEPT({}, {}) Local Stage: {}",
+                            tx_rec.transaction_id(),
+                            tx_rec.current_decision(),
+                            tx_rec.current_stage()
+                        );
+                        tx_rec.add_pending_status_update(
+                            tx,
+                            leaf.as_leaf_block(),
+                            TransactionPoolStage::LocalPrepared,
+                            true,
+                        )?;
+                    }
+                },
+                Command::Accept(_) => {},
+            }
+        }
+        leaf.set_as_processed(tx)?;
+        Ok(())
     }
 
     /// if b_new .height > vheight && (b_new extends b_lock || b_new .justify.node.height > b_lock .height)
@@ -363,14 +459,15 @@ where TConsensusSpec: ConsensusSpec
         block: &Block<TConsensusSpec::Addr>,
         foreign_committee_shard: &CommitteeShard,
     ) -> Result<(), HotStuffError> {
-        // Save the QCs if it doesnt exist already, we'll reference the QC in subsequent blocks
-        block.justify().save(tx)?;
+        let leaf = LeafBlock::get(tx.deref_mut())?;
+        // We only want to save the QC once if applicable
+        let mut is_qc_saved = false;
 
         for cmd in block.commands() {
             let Some(t) = cmd.local_prepared() else {
                 continue;
             };
-            let Some(mut tx_rec) = self.transaction_pool.get(tx, &t.id).optional()? else {
+            let Some(mut tx_rec) = self.transaction_pool.get(tx, leaf, &t.id).optional()? else {
                 continue;
             };
 
@@ -383,22 +480,37 @@ where TConsensusSpec: ConsensusSpec
                 continue;
             }
 
-            tx_rec.update_evidence(tx, foreign_committee_shard, *block.justify().id())?;
-            let change_to_abort = cmd.decision().is_abort() && tx_rec.original_decision().is_commit();
-            if change_to_abort {
+            let remote_decision = cmd.decision();
+            let local_decision = tx_rec.current_local_decision();
+            if remote_decision.is_abort() && local_decision.is_commit() {
                 info!(
                     target: LOG_TARGET,
-                    "⚠️ Foreign shard ABORT {}. Update decision to ABORT",
-                    tx_rec.transaction_id()
+                    "⚠️ Foreign shard ABORT {}. Update overall decision to ABORT. Local stage: {}, Leaf: {}",
+                    tx_rec.transaction_id(), tx_rec.current_stage(), leaf
                 );
-                tx_rec.update_remote_decision(tx, Decision::Abort)?;
             }
 
+            if !is_qc_saved {
+                // Save the QCs if it doesnt exist already, we'll reference the QC in subsequent blocks
+                block.justify().save(tx)?;
+                is_qc_saved = true;
+            }
+
+            tx_rec.update_remote_data(tx, remote_decision, *block.justify().id(), foreign_committee_shard)?;
+
             // If all shards are complete and we've already received our LocalPrepared, we can set out LocalPrepared
             // transaction as ready to propose ACCEPT. If we have not received the local LocalPrepared, the transition
             // will happen when we receive the local block.
             if tx_rec.current_stage().is_local_prepared() && tx_rec.transaction().evidence.all_shards_complete() {
-                tx_rec.pending_transition(tx, TransactionPoolStage::LocalPrepared, true)?;
+                info!(
+                    target: LOG_TARGET,
+                    "🔥 FOREIGN PROPOSAL: Transaction is ready for propose ACCEPT({}, {}) Local Stage: {}",
+                    tx_rec.transaction_id(),
+                    tx_rec.current_decision(),
+                    tx_rec.current_stage()
+                );
+
+                tx_rec.add_pending_status_update(tx, leaf, TransactionPoolStage::LocalPrepared, true)?;
             }
         }
 
@@ -410,36 +522,43 @@ where TConsensusSpec: ConsensusSpec
         local_committee: &Committee<TConsensusSpec::Addr>,
         height: NodeHeight,
         message: HotstuffMessage<TConsensusSpec::Addr>,
-    ) -> Result<(), HotStuffError> {
+    ) {
         let leader = self.leader_strategy.get_leader(local_committee, height);
-        self.tx_leader
-            .send((leader.clone(), message))
-            .await
-            .map_err(|_| HotStuffError::InternalChannelClosed {
-                context: "tx_leader in OnReceiveProposalHandler::send_to_leader",
-            })
+        if self.tx_leader.send((leader.clone(), message)).await.is_err() {
+            debug!(
+                target: LOG_TARGET,
+                "tx_leader in OnReceiveProposalHandler::send_to_leader is closed",
+            );
+        }
     }
 
     async fn send_vote_to_leader(
         &self,
         local_committee: &Committee<TConsensusSpec::Addr>,
         vote: VoteMessage<TConsensusSpec::Addr>,
-        height: NodeHeight,
-    ) -> Result<(), HotStuffError> {
-        let leader = self.leader_strategy.get_leader_for_next_block(local_committee, height);
+        block: &Block<TConsensusSpec::Addr>,
+    ) {
+        let leader = self
+            .leader_strategy
+            .get_leader_for_next_block(local_committee, block.height());
         info!(
             target: LOG_TARGET,
             "🔥 VOTE {:?} for block {} to next leader {:.4}",
             vote.decision,
-            vote.block_id,
+            block,
             leader,
         );
-        self.tx_leader
+        if self
+            .tx_leader
             .send((leader.clone(), HotstuffMessage::Vote(vote)))
             .await
-            .map_err(|_| HotStuffError::InternalChannelClosed {
-                context: "tx_leader in OnReceiveProposalHandler::send_vote_to_leader",
-            })
+            .is_err()
+        {
+            debug!(
+                target: LOG_TARGET,
+                "tx_leader in OnReceiveProposalHandler::send_vote_to_leader is closed",
+            );
+        }
     }
 
     #[allow(clippy::too_many_lines)]
@@ -448,26 +567,32 @@ where TConsensusSpec: ConsensusSpec
         tx: &mut <TConsensusSpec::StateStore as StateStore>::WriteTransaction<'_>,
         block: &Block<TConsensusSpec::Addr>,
         local_committee_shard: &CommitteeShard,
-    ) -> Result<(Option<QuorumDecision>, Vec<TransactionPoolRecord>), HotStuffError> {
+    ) -> Result<BlockDecision, HotStuffError> {
         let mut total_leader_fee = 0;
-        let mut abort_transactions = Vec::new();
         let mut decision = BlockDecision::vote_accept();
+        let mut locked_inputs = HashSet::new();
+        let mut locked_outputs = HashSet::new();
         for cmd in block.commands() {
-            let Some(mut tx_rec) = self.transaction_pool.get(tx, cmd.transaction_id()).optional()? else {
+            let Some(mut tx_rec) = self
+                .transaction_pool
+                .get(tx, block.as_leaf_block(), cmd.transaction_id())
+                .optional()?
+            else {
                 warn!(
                     target: LOG_TARGET,
-                    "⚠️ Local proposal received ({}) for transaction {} which is not in the pool. Ignoring.",
+                    "⚠️ Local proposal received ({}) for transaction {} which is not in the pool. This is likely a previous transaction that has been re-proposed. Not voting on block.",
                     block,
                     cmd.transaction_id(),
                 );
                 decision.dont_vote();
-                continue;
+                return Ok(decision);
             };
+
             // 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,
             //       this should be less common.
-            tx_rec.update_evidence(tx, local_committee_shard, *block.justify().id())?;
+            tx_rec.add_evidence(local_committee_shard, *block.justify().id());
 
             debug!(
                 target: LOG_TARGET,
@@ -502,66 +627,73 @@ where TConsensusSpec: ConsensusSpec
                     }
 
                     if tx_rec.current_decision() == t.decision {
-                        // We allow blocks to ask us to prepare more than once - only lock objects if the stage is New
-                        if tx_rec.current_stage().is_new() {
-                            if tx_rec.current_decision().is_commit() {
-                                let transaction = ExecutedTransaction::get(tx.deref_mut(), cmd.transaction_id())?;
-                                // Lock all inputs for the transaction as part of LocalPrepare
-                                if !self.lock_inputs(tx, transaction.transaction(), local_committee_shard)? {
-                                    // Unable to lock all inputs - do not vote
-                                    warn!(
-                                        target: LOG_TARGET,
-                                        "❌ Unable to lock all inputs for transaction {} in block {}. Leader proposed {}, we decided {}",
-                                        block.id(),
-                                        transaction.id(),
-                                        t.decision,
-                                        Decision::Abort
-                                    );
-                                    // We change our decision to ABORT so that the next time we propose/receive a
-                                    // proposal we will check for ABORT. It may
-                                    // happen that the transaction causing the lock failure
-                                    // is ABORTED too and the locks released allowing this transaction to succeed.
-                                    // Currently, the client would have to resubmit the transaction to resolve this.
-                                    // tx_rec.update_local_decision(tx, Decision::Abort)?;
-                                    abort_transactions.push(tx_rec);
-                                    // This brings up an interesting problem. If we decide to abstain from voting, then
-                                    // object conflicts essentially induce leader failures. This is problematic since it
-                                    // puts leader failure under the control of users and potentially malicious parties.
-                                    decision.dont_vote();
-                                    continue;
-                                }
-                                if !self.lock_outputs(tx, block.id(), &transaction)? {
-                                    // Unable to lock all outputs - do not vote
-                                    warn!(
-                                        target: LOG_TARGET,
-                                        "❌ Unable to lock all outputs for transaction {} in block {}. Leader proposed {}, we decided {}",
-                                        block.id(),
-                                        transaction.id(),
-                                        t.decision,
-                                        Decision::Abort
-                                    );
-                                    // We change our decision to ABORT so that the next time we propose/receive a
-                                    // proposal we will check for ABORT
-                                    abort_transactions.push(tx_rec);
-                                    // tx_rec.update_local_decision(tx, Decision::Abort)?;
-                                    decision.dont_vote();
-                                    continue;
-                                }
+                        if tx_rec.current_decision().is_commit() {
+                            let transaction = ExecutedTransaction::get(tx.deref_mut(), cmd.transaction_id())?;
+                            // Lock all inputs for the transaction as part of Prepare
+                            let is_inputs_locked = self.check_lock_inputs(
+                                tx,
+                                transaction.transaction(),
+                                local_committee_shard,
+                                &mut locked_inputs,
+                            )?;
+                            let is_outputs_locked =
+                                is_inputs_locked && self.check_lock_outputs(tx, &transaction, &mut locked_outputs)?;
+
+                            if !is_inputs_locked {
+                                // Unable to lock all inputs - do not vote
+                                warn!(
+                                    target: LOG_TARGET,
+                                    "❌ Unable to lock all inputs for transaction {} in block {}.",
+                                    block.id(),
+                                    transaction.id(),
+                                );
+                                // We change our decision to ABORT so that the next time we propose/receive a
+                                // proposal we will check for ABORT. It may
+                                // happen that the transaction causing the lock failure
+                                // is ABORTED too and the locks released allowing this transaction to succeed.
+                                // Currently, the client would have to resubmit the transaction to resolve this.
+                                tx_rec.update_local_decision(tx, Decision::Abort)?;
+
+                                // The leader should not have proposed conflicting transactions
+                                decision.dont_vote();
+                                return Ok(decision);
+                            } else if !is_outputs_locked {
+                                // Unable to lock all outputs - do not vote
+                                warn!(
+                                    target: LOG_TARGET,
+                                    "❌ Unable to lock all outputs for transaction {} in block {}.",
+                                    block.id(),
+                                    transaction.id(),
+                                );
+                                // We change our decision to ABORT so that the next time we propose/receive a
+                                // proposal we will check for ABORT
+                                tx_rec.update_local_decision(tx, Decision::Abort)?;
+                                decision.dont_vote();
+                                return Ok(decision);
+                            } else {
+                                // We have locked all inputs and outputs
                             }
+                        }
 
-                            tx_rec.pending_transition(tx, TransactionPoolStage::Prepared, true)?;
+                        if decision.is_accept() {
+                            tx_rec.add_pending_status_update(
+                                tx,
+                                block.as_leaf_block(),
+                                TransactionPoolStage::Prepared,
+                                true,
+                            )?;
                         }
                     } else {
                         // If we disagree with any local decision we abstain from voting
                         warn!(
                             target: LOG_TARGET,
-                            "❌ Prepare decision disagreement for block {}. Leader proposed {}, we decided {}",
+                            "❌ Prepare decision disagreement for tx {} in block {}. Leader proposed {}, we decided {}",
+                            tx_rec.transaction_id(),
                             block.id(),
                             t.decision,
                             tx_rec.current_decision()
                         );
                         decision.dont_vote();
-                        continue;
                     }
                 },
                 Command::LocalPrepared(t) => {
@@ -569,16 +701,16 @@ where TConsensusSpec: ConsensusSpec
                     // We only mark the next step (Accept) as ready to propose once all shards have reported
                     // LocalPrepared.
 
-                    if !tx_rec.current_stage().is_prepared() {
+                    if !tx_rec.current_stage().is_prepared() && !tx_rec.current_stage().is_local_prepared() {
                         warn!(
                             target: LOG_TARGET,
-                            "❌ Stage disagreement in block {} for transaction {}. Leader proposed LocalPrepared, but local stage is {}",
+                            "{} ❌ Stage disagreement in block {} for transaction {}. Leader proposed LocalPrepared, but local stage is {}",
+                            self.validator_addr,
                             block.id(),
                             tx_rec.transaction_id(),
                             tx_rec.current_stage()
                         );
                         decision.dont_vote();
-                        continue;
                     }
                     // We check that the leader decision is the same as our local decision.
                     // We disregard the remote decision because not all validators may have received the foreign
@@ -594,31 +726,33 @@ where TConsensusSpec: ConsensusSpec
                         );
 
                         decision.dont_vote();
-                        continue;
                     }
 
                     if tx_rec.transaction().transaction_fee != t.transaction_fee {
                         warn!(
                             target: LOG_TARGET,
-                            "❌ Accept transaction fee disagreement for block {}. Leader proposed {}, we calculated {}",
+                            "❌ Accept transaction fee disagreement tx {} in block {}. Leader proposed {}, we calculated {}",
+                            tx_rec.transaction_id(),
                             block.id(),
                             t.transaction_fee,
                             tx_rec.transaction().transaction_fee
                         );
                         decision.dont_vote();
-                        continue;
                     }
 
-                    tx_rec.pending_transition(
-                        tx,
-                        TransactionPoolStage::LocalPrepared,
-                        tx_rec.transaction().evidence.all_shards_complete(),
-                    )?;
+                    if decision.is_accept() {
+                        tx_rec.add_pending_status_update(
+                            tx,
+                            block.as_leaf_block(),
+                            TransactionPoolStage::LocalPrepared,
+                            tx_rec.transaction().evidence.all_shards_complete(),
+                        )?;
+                    }
                 },
                 Command::Accept(t) => {
                     // Happy path: We've validated all the QCs and therefore are convinced that everyone also received
                     // LocalPrepare. We then propose new blocks until we have a 3-chain
-                    if !tx_rec.current_stage().is_local_prepared() {
+                    if !tx_rec.current_stage().is_local_prepared() && !tx_rec.current_stage().is_accepted() {
                         warn!(
                             target: LOG_TARGET,
                             "❌ Stage disagreement for tx {} in block {}. Leader proposed Accept, local stage {}",
@@ -632,7 +766,8 @@ where TConsensusSpec: ConsensusSpec
                     if tx_rec.current_decision() != t.decision {
                         warn!(
                             target: LOG_TARGET,
-                            "❌ Accept decision disagreement for block {}. Leader proposed {}, we decided {}",
+                            "❌ Accept decision disagreement tx {} in for block {}. Leader proposed {}, we decided {}",
+                            tx_rec.transaction_id(),
                             block.id(),
                             t.decision,
                             tx_rec.current_decision()
@@ -644,7 +779,8 @@ where TConsensusSpec: ConsensusSpec
                     if !tx_rec.transaction().evidence.all_shards_complete() {
                         warn!(
                             target: LOG_TARGET,
-                            "❌ Accept evidence disagreement for block {}. Evidence for {} out of {} shards",
+                            "❌ Accept evidence disagreement tx {} in block {}. Evidence for {} out of {} shards",
+                            tx_rec.transaction_id(),
                             block.id(),
                             tx_rec.transaction().evidence.num_complete_shards(),
                             tx_rec.transaction().evidence.len(),
@@ -656,7 +792,8 @@ where TConsensusSpec: ConsensusSpec
                     if tx_rec.transaction().transaction_fee != t.transaction_fee {
                         warn!(
                             target: LOG_TARGET,
-                            "❌ Accept transaction fee disagreement for block {}. Leader proposed {}, we calculated {}",
+                            "❌ Accept transaction fee disagreement tx {} in block {}. Leader proposed {}, we calculated {}",
+                            tx_rec.transaction_id(),
                             block.id(),
                             t.transaction_fee,
                             tx_rec.transaction().transaction_fee
@@ -666,6 +803,21 @@ where TConsensusSpec: ConsensusSpec
                         continue;
                     }
 
+                    // Check if we have LocalPrepared ready i.e. LocalPrepared from all shards
+                    // It is possible that the transaction was not marked as ready yet because of the order we received
+                    // messages, but if we are in LocalPrepared and we have all the evidence, we would have proposed
+                    // this too so we can continue.
+                    if !tx_rec.is_ready() && !tx_rec.transaction().evidence.all_shards_complete() {
+                        warn!(
+                            target: LOG_TARGET,
+                            "⚠️ Local proposal received ({}) for transaction {} which is not ready. Not voting.",
+                            block,
+                            tx_rec.transaction()
+                        );
+                        decision.dont_vote();
+                        continue;
+                    }
+
                     let distinct_shards =
                         local_committee_shard.count_distinct_buckets(tx_rec.transaction().evidence.shards_iter());
                     let distinct_shards = NonZeroU64::new(distinct_shards as u64).ok_or_else(|| {
@@ -692,17 +844,27 @@ where TConsensusSpec: ConsensusSpec
                     // If the decision was changed to Abort, which can only happen when a foreign shard decides ABORT
                     // and we decide COMMIT, we set SomePrepared, otherwise AllPrepared. There are no further stages
                     // after these, so these MUST never be ready to propose.
-                    if tx_rec.remote_decision().map(|d| d.is_abort()).unwrap_or(false) {
-                        tx_rec.pending_transition(tx, TransactionPoolStage::SomePrepared, false)?;
-                    } else {
-                        tx_rec.pending_transition(tx, TransactionPoolStage::AllPrepared, false)?;
+                    if decision.is_accept() {
+                        if tx_rec.remote_decision().map(|d| d.is_abort()).unwrap_or(false) {
+                            tx_rec.add_pending_status_update(
+                                tx,
+                                block.as_leaf_block(),
+                                TransactionPoolStage::SomePrepared,
+                                false,
+                            )?;
+                        } else {
+                            tx_rec.add_pending_status_update(
+                                tx,
+                                block.as_leaf_block(),
+                                TransactionPoolStage::AllPrepared,
+                                false,
+                            )?;
+                        }
                     }
                 },
             }
         }
 
-        block.set_as_processed(tx)?;
-
         // If we decided not to vote, the total_leader_fee may be incorrectly summed up.
         if decision.is_accept() && total_leader_fee != block.total_leader_fee() {
             warn!(
@@ -715,7 +877,7 @@ where TConsensusSpec: ConsensusSpec
             decision.dont_vote();
         }
 
-        Ok((decision.as_quorum_decision(), abort_transactions))
+        Ok(decision)
     }
 
     fn lock_inputs(
@@ -765,6 +927,62 @@ where TConsensusSpec: ConsensusSpec
         Ok(true)
     }
 
+    fn check_lock_inputs(
+        &self,
+        tx: &mut <TConsensusSpec::StateStore as StateStore>::ReadTransaction<'_>,
+        transaction: &Transaction,
+        local_committee_shard: &CommitteeShard,
+        locked_inputs: &mut HashSet<ShardId>,
+    ) -> Result<bool, HotStuffError> {
+        let inputs = local_committee_shard
+            .filter(transaction.inputs().iter().chain(transaction.filled_inputs()))
+            .copied()
+            .collect::<HashSet<_>>();
+        let state = SubstateRecord::check_lock_all(tx, inputs.iter(), SubstateLockFlag::Write)?;
+        if !state.is_acquired() {
+            warn!(
+                target: LOG_TARGET,
+                "❌ Unable to write lock all inputs for transaction {}: {:?}",
+                transaction.id(),
+                state,
+            );
+            return Ok(false);
+        }
+        if inputs.iter().any(|i| locked_inputs.contains(i)) {
+            warn!(
+                target: LOG_TARGET,
+                "❌ Locks for transaction {} conflict with other transactions in the block",
+                transaction.id(),
+            );
+            return Ok(false);
+        }
+        locked_inputs.extend(inputs);
+
+        let state = SubstateRecord::check_lock_all(
+            tx,
+            local_committee_shard.filter(transaction.input_refs()),
+            SubstateLockFlag::Read,
+        )?;
+
+        if !state.is_acquired() {
+            warn!(
+                target: LOG_TARGET,
+                "❌ Unable to read lock all input refs for transaction {}: {:?}",
+                transaction.id(),
+                state,
+            );
+            return Ok(false);
+        }
+
+        debug!(
+            target: LOG_TARGET,
+            "🔒️ Locked inputs for transaction {}",
+            transaction.id(),
+        );
+
+        Ok(true)
+    }
+
     fn unlock_inputs(
         &self,
         tx: &mut <TConsensusSpec::StateStore as StateStore>::WriteTransaction<'_>,
@@ -809,6 +1027,35 @@ where TConsensusSpec: ConsensusSpec
         Ok(true)
     }
 
+    fn check_lock_outputs(
+        &self,
+        tx: &mut <TConsensusSpec::StateStore as StateStore>::ReadTransaction<'_>,
+        transaction: &ExecutedTransaction,
+        locked_outputs: &mut HashSet<ShardId>,
+    ) -> Result<bool, HotStuffError> {
+        let state = LockedOutput::check_locks(tx, transaction.resulting_outputs())?;
+
+        if !state.is_acquired() {
+            return Ok(false);
+        }
+
+        if transaction
+            .resulting_outputs()
+            .iter()
+            .any(|i| locked_outputs.contains(i))
+        {
+            warn!(
+                target: LOG_TARGET,
+                "❌ Locks for transaction {} conflict with other transactions in the block",
+                transaction.id(),
+            );
+            return Ok(false);
+        }
+        locked_outputs.extend(transaction.resulting_outputs());
+
+        Ok(true)
+    }
+
     fn unlock_outputs(
         &self,
         tx: &mut <TConsensusSpec::StateStore as StateStore>::WriteTransaction<'_>,
@@ -874,63 +1121,32 @@ where TConsensusSpec: ConsensusSpec
     fn on_lock_block(
         &self,
         tx: &mut <TConsensusSpec::StateStore as StateStore>::WriteTransaction<'_>,
+        locked: &LockedBlock,
         block: &Block<TConsensusSpec::Addr>,
     ) -> Result<(), HotStuffError> {
-        info!(
-            target: LOG_TARGET,
-            "🔒️ LOCKED BLOCK: {} {}",
-            block.height(),
-            block.id()
-        );
-
-        // self.process_commands(tx, local_committee_shard, block)?;
+        if locked.height < block.height() {
+            info!(
+                target: LOG_TARGET,
+                "🔒️ LOCKED BLOCK: {} {}",
+                block.height(),
+                block.id()
+            );
 
-        // This moves the stage update from pending to current for all transactions on on the locked block
-        self.transaction_pool
-            .confirm_all_transitions(tx, block.all_transaction_ids())?;
+            let parent = block.get_parent(tx.deref_mut())?;
+            self.on_lock_block(tx, locked, &parent)?;
+
+            // self.processed_locked_commands(tx, local_committee_shard, block)?;
+            // This moves the stage update from pending to current for all transactions on on the locked block
+            self.transaction_pool.confirm_all_transitions(
+                tx,
+                locked,
+                &block.as_locked_block(),
+                block.all_transaction_ids(),
+            )?;
+        }
         Ok(())
     }
 
-    // fn process_commands(
-    //     &self,
-    //     tx: &mut <TConsensusSpec::StateStore as StateStore>::WriteTransaction<'_>,
-    //     local_committee_shard: &CommitteeShard,
-    //     block: &Block<TConsensusSpec::Addr>,
-    // ) -> Result<(), HotStuffError> { for cmd in block.commands() { let mut tx_rec = self.transaction_pool.get(tx,
-    //   cmd.transaction_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, //
-    //   this should be less common. tx_rec.update_evidence(tx, local_committee_shard, *block.justify().id())?;
-    //
-    //         match cmd {
-    //             Command::Prepare(_) => {
-    //                 tx_rec.pending_transition(tx, TransactionPoolStage::Prepared, true)?;
-    //             },
-    //             Command::LocalPrepared(t) => {
-    //                 tx_rec.pending_transition(
-    //                     tx,
-    //                     TransactionPoolStage::LocalPrepared,
-    //                     tx_rec.transaction().evidence.all_shards_complete(),
-    //                 )?;
-    //                 tx_rec.update_local_decision(tx, t.decision)?;
-    //             },
-    //             Command::Accept(t) => {
-    //                 // If the decision was changed to Abort, which can only happen when a foreign shard decides ABORT
-    //                 // and we decide COMMIT, we set SomePrepared, otherwise AllPrepared. There are no further stages
-    //                 // after these, so these MUST never be ready to propose.
-    //                 if tx_rec.remote_decision().map(|d| d.is_abort()).unwrap_or(false) {
-    //                     tx_rec.pending_transition(tx, TransactionPoolStage::SomePrepared, false)?;
-    //                 } else {
-    //                     tx_rec.pending_transition(tx, TransactionPoolStage::AllPrepared, false)?;
-    //                 }
-    //                 tx_rec.update_remote_decision(tx, t.decision)?;
-    //             },
-    //         }
-    //     }
-    //
-    //     Ok(())
-    // }
-
     fn publish_event(&self, event: HotstuffEvent) {
         let _ignore = self.tx_events.send(event);
     }
@@ -950,29 +1166,34 @@ where TConsensusSpec: ConsensusSpec
                     // TODO: Check if it's ok to unlock the inputs for ABORT at this point
                 },
                 Command::Accept(t) => {
-                    let tx_rec = self.transaction_pool.get(tx, cmd.transaction_id())?;
+                    let tx_rec = self
+                        .transaction_pool
+                        .get(tx, block.as_leaf_block(), cmd.transaction_id())?;
                     debug!(
                         target: LOG_TARGET,
                         "Transaction {} is finalized ({})", tx_rec.transaction_id(), t.decision
                     );
 
-                    if t.decision != tx_rec.current_decision() {
-                        return Err(HotStuffError::InvariantError(format!(
-                            "Transaction {} decision mismatch on COMMIT block {}. Block decision {}, local decision: \
-                             {}",
-                            tx_rec.transaction_id(),
-                            block.id(),
-                            t.decision,
-                            tx_rec.current_decision(),
-                        )));
-                    }
-
                     total_transaction_fee += tx_rec.transaction().transaction_fee;
                     total_fee_due += t.leader_fee;
 
                     let mut executed = t.get_transaction(tx.deref_mut())?;
                     // Commit the transaction substate changes.
-                    if tx_rec.current_decision().is_commit() {
+                    if t.decision.is_commit() {
+                        if let Some(reject_reason) = executed.result().finalize.reject() {
+                            warn!(
+                                target: LOG_TARGET,
+                                "⚠️ We are unable to execute the block {} because transaction {} failed to execute but the committee decided to ACCEPT it.",
+                                block,
+                                tx_rec.transaction_id()
+                            );
+                            return Err(HotStuffError::RejectedTransactionCommitDecision {
+                                block_id: *block.id(),
+                                transaction_id: *tx_rec.transaction_id(),
+                                reject_reason: reject_reason.to_string(),
+                            });
+                        }
+
                         self.state_manager
                             .commit_transaction(tx, block, &executed)
                             .map_err(|e| HotStuffError::StateManagerError(e.into()))?;
@@ -1031,6 +1252,14 @@ where TConsensusSpec: ConsensusSpec
         }
         self.validate_proposed_block(from, candidate_block)?;
 
+        if Block::has_been_processed(tx.deref_mut(), candidate_block.id())? {
+            return Err(ProposalValidationError::BlockAlreadyProcessed {
+                block_id: *candidate_block.id(),
+                height: candidate_block.height(),
+            }
+            .into());
+        }
+
         // Check that details included in the justify match previously added blocks
         let Some(justify_block) = candidate_block.justify().get_block(tx.deref_mut()).optional()? else {
             // This will trigger a sync
@@ -1061,15 +1290,15 @@ where TConsensusSpec: ConsensusSpec
         }
 
         // Part of the safenode predicate. Exclude this block early if this is the case
-        let locked_block = LockedBlock::get(tx.deref_mut())?;
-        if !locked_block.block_id.is_genesis() && candidate_block.justify().block_height() < locked_block.height() {
-            return Err(ProposalValidationError::CandidateBlockNotHigherThanLockedBlock {
-                proposed_by: from.to_string(),
-                locked_block,
-                candidate_block: candidate_block.as_leaf_block(),
-            }
-            .into());
-        }
+        // let locked_block = LockedBlock::get(tx.deref_mut())?;
+        // if !locked_block.block_id.is_genesis() && candidate_block.justify().block_height() < locked_block.height() {
+        //     return Err(ProposalValidationError::CandidateBlockNotHigherThanLockedBlock {
+        //         proposed_by: from.to_string(),
+        //         locked_block,
+        //         candidate_block: candidate_block.as_leaf_block(),
+        //     }
+        //     .into());
+        // }
 
         // candidate_block.justify().update_high_qc(tx)?;
 
@@ -1104,21 +1333,17 @@ where TConsensusSpec: ConsensusSpec
                 .into());
             }
 
-            let high_qc = HighQc::get(tx.deref_mut())?.get_quorum_certificate(tx.deref_mut())?;
-
             if justify_block.id() == candidate_block.parent() {
                 return Ok(());
             }
 
             let justify_block_height = justify_block.height();
 
-            // self.undo_other_chains(tx, &justify_block)?;
-
             let mut last_dummy_block = justify_block;
 
             while last_dummy_block.id() != candidate_block.parent() {
                 if last_dummy_block.height() > candidate_block.height() {
-                    warn!(target: LOG_TARGET, "🔥 Bad proposal, dummy block height {} is greater than new height {}", last_dummy_block.height(), candidate_block.height());
+                    warn!(target: LOG_TARGET, "🔥 Bad proposal, dummy block height {} is greater than new height {}", last_dummy_block, candidate_block);
                     return Err(ProposalValidationError::CandidateBlockDoesNotExtendJustify {
                         justify_block_height,
                         candidate_block_height: candidate_block.height(),
@@ -1134,7 +1359,7 @@ where TConsensusSpec: ConsensusSpec
                     *last_dummy_block.id(),
                     leader.clone(),
                     next_height,
-                    high_qc.clone(),
+                    candidate_block.justify().clone(),
                     candidate_block.epoch(),
                 );
                 debug!(target: LOG_TARGET, "🍼 DUMMY BLOCK: {}. Leader: {}", last_dummy_block, leader);
@@ -1147,36 +1372,6 @@ where TConsensusSpec: ConsensusSpec
         Ok(())
     }
 
-    // fn undo_other_chains(
-    //     &self,
-    //     tx: &mut <TConsensusSpec::StateStore as StateStore>::WriteTransaction<'_>,
-    //     base_block: &Block<TConsensusSpec::Addr>,
-    // ) -> Result<(), HotStuffError> { let child_blocks = base_block.get_child_blocks(tx.deref_mut())?; if
-    //   child_blocks.is_empty() { return Ok(()); }
-    //
-    //     for child_block in child_blocks {
-    //         if child_block.is_genesis() {
-    //             return Ok(());
-    //         }
-    //         info!(
-    //             target: LOG_TARGET,
-    //             "🔙 Undoing block {} from chain {}", child_block, base_block);
-    //
-    //         if child_block.is_processed() {
-    //             self.transaction_pool.rollback_pending_stages(tx, &child_block)?;
-    //         }
-    //         if *child_block.proposed_by() == self.validator_addr {
-    //             child_block.as_last_proposed().unset(tx)?;
-    //         }
-    //         child_block.as_last_voted().unset(tx)?;
-    //         child_block.as_leaf_block().unset(tx)?;
-    //         child_block.unset_as_processed(tx)?;
-    //
-    //         self.undo_other_chains(tx, &child_block)?;
-    //     }
-    //     Ok(())
-    // }
-
     fn validate_proposed_block(
         &self,
         from: &TConsensusSpec::Addr,
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 23d58db3b..dd7b7b803 100644
--- a/dan_layer/consensus/src/hotstuff/on_receive_requested_transactions.rs
+++ b/dan_layer/consensus/src/hotstuff/on_receive_requested_transactions.rs
@@ -30,6 +30,7 @@ where TConsensusSpec: ConsensusSpec
         msg: RequestedTransactionMessage,
     ) -> Result<(), HotStuffError> {
         info!(target: LOG_TARGET, "{:?} receiving {} requested transactions for block {}", from, msg.transactions.len(), msg.block_id);
+        // TODO: Check that we requested this
         for tx in msg.transactions {
             self.tx_mempool
                 .send(tx)
diff --git a/dan_layer/consensus/src/hotstuff/on_receive_vote.rs b/dan_layer/consensus/src/hotstuff/on_receive_vote.rs
index 7b11cc86a..27346eeab 100644
--- a/dan_layer/consensus/src/hotstuff/on_receive_vote.rs
+++ b/dan_layer/consensus/src/hotstuff/on_receive_vote.rs
@@ -122,7 +122,7 @@ where TConsensusSpec: ConsensusSpec
             let Some(block) = Block::get(tx.deref_mut(), &message.block_id).optional()? else {
                 warn!(
                     target: LOG_TARGET,
-                    "❌ Received vote for unknown block {} from {}", message.block_id, from
+                    "❌ Received {} votes for unknown block {}", count, message.block_id
                 );
                 tx.rollback()?;
                 return Ok(());
diff --git a/dan_layer/consensus/src/hotstuff/pacemaker.rs b/dan_layer/consensus/src/hotstuff/pacemaker.rs
index aa4c116cb..1e7e4f855 100644
--- a/dan_layer/consensus/src/hotstuff/pacemaker.rs
+++ b/dan_layer/consensus/src/hotstuff/pacemaker.rs
@@ -134,8 +134,8 @@ impl PaceMaker {
                     let delta = self.delta_time();
                     leader_timeout.as_mut().reset(tokio::time::Instant::now() + delta);
                     info!(target: LOG_TARGET, "⚠️ Leader timeout! Current height: {}, Delta: {:.2?}", self.current_height, delta);
-                    on_leader_timeout.leader_timed_out(self.current_height);
                     self.current_height += NodeHeight(1);
+                    on_leader_timeout.leader_timed_out(self.current_height);
                 },
 
             }
diff --git a/dan_layer/consensus/src/hotstuff/state_machine/mod.rs b/dan_layer/consensus/src/hotstuff/state_machine/mod.rs
index f29057b7c..26ab3093c 100644
--- a/dan_layer/consensus/src/hotstuff/state_machine/mod.rs
+++ b/dan_layer/consensus/src/hotstuff/state_machine/mod.rs
@@ -9,4 +9,5 @@ mod state;
 mod syncing;
 mod worker;
 
+pub use state::ConsensusCurrentState;
 pub use worker::{ConsensusWorker, ConsensusWorkerContext};
diff --git a/dan_layer/consensus/src/hotstuff/state_machine/state.rs b/dan_layer/consensus/src/hotstuff/state_machine/state.rs
index eef6befde..1d0925ad1 100644
--- a/dan_layer/consensus/src/hotstuff/state_machine/state.rs
+++ b/dan_layer/consensus/src/hotstuff/state_machine/state.rs
@@ -15,6 +15,23 @@ pub(super) enum ConsensusState<TSpec> {
     Shutdown,
 }
 
+#[derive(Debug, Clone, Copy, Default)]
+pub enum ConsensusCurrentState {
+    #[default]
+    Idle,
+    CheckSync,
+    Syncing,
+    Running,
+    Sleeping,
+    Shutdown,
+}
+
+impl ConsensusCurrentState {
+    pub fn is_running(&self) -> bool {
+        matches!(self, ConsensusCurrentState::Running)
+    }
+}
+
 impl<TSpec> ConsensusState<TSpec> {
     pub fn is_shutdown(&self) -> bool {
         matches!(self, ConsensusState::Shutdown)
@@ -35,3 +52,16 @@ impl<TSpec> Display for ConsensusState<TSpec> {
         }
     }
 }
+
+impl<TSpec> From<&ConsensusState<TSpec>> for ConsensusCurrentState {
+    fn from(value: &ConsensusState<TSpec>) -> Self {
+        match value {
+            ConsensusState::Idle(_) => ConsensusCurrentState::Idle,
+            ConsensusState::CheckSync(_) => ConsensusCurrentState::CheckSync,
+            ConsensusState::Syncing(_) => ConsensusCurrentState::Syncing,
+            ConsensusState::Running(_) => ConsensusCurrentState::Running,
+            ConsensusState::Sleeping => ConsensusCurrentState::Sleeping,
+            ConsensusState::Shutdown => ConsensusCurrentState::Shutdown,
+        }
+    }
+}
diff --git a/dan_layer/consensus/src/hotstuff/state_machine/worker.rs b/dan_layer/consensus/src/hotstuff/state_machine/worker.rs
index 450210b3e..a864d99ff 100644
--- a/dan_layer/consensus/src/hotstuff/state_machine/worker.rs
+++ b/dan_layer/consensus/src/hotstuff/state_machine/worker.rs
@@ -6,11 +6,18 @@ use std::{future::Future, marker::PhantomData, time::Duration};
 use log::*;
 use tari_epoch_manager::EpochManagerEvent;
 use tari_shutdown::ShutdownSignal;
-use tokio::{sync::broadcast, time};
+use tokio::{
+    sync::{broadcast, watch},
+    time,
+};
 
 use crate::{
     hotstuff::{
-        state_machine::{event::ConsensusStateEvent, idle::IdleState, state::ConsensusState},
+        state_machine::{
+            event::ConsensusStateEvent,
+            idle::IdleState,
+            state::{ConsensusCurrentState, ConsensusState},
+        },
         HotStuffError,
         HotstuffWorker,
     },
@@ -31,6 +38,7 @@ pub struct ConsensusWorkerContext<TSpec: ConsensusSpec> {
     pub epoch_events: broadcast::Receiver<EpochManagerEvent>,
     pub hotstuff: HotstuffWorker<TSpec>,
     pub state_sync: TSpec::SyncManager,
+    pub tx_current_state: watch::Sender<ConsensusCurrentState>,
 }
 
 impl<TSpec> ConsensusWorker<TSpec>
@@ -108,6 +116,7 @@ where
         loop {
             let next_event = self.next_event(&mut context, &state).await;
             state = self.transition(state, next_event);
+            let _ignore = context.tx_current_state.send((&state).into());
             if state.is_shutdown() {
                 break;
             }
diff --git a/dan_layer/consensus/src/hotstuff/worker.rs b/dan_layer/consensus/src/hotstuff/worker.rs
index 02b0ae860..2981503bd 100644
--- a/dan_layer/consensus/src/hotstuff/worker.rs
+++ b/dan_layer/consensus/src/hotstuff/worker.rs
@@ -298,7 +298,7 @@ where TConsensusSpec: ConsensusSpec
     }
 
     async fn propose_if_leader(&mut self, leaf_block: Option<LeafBlock>) -> Result<(), HotStuffError> {
-        let must_propose = leaf_block.is_some();
+        let is_newview_propose = leaf_block.is_some();
         let leaf_block = match leaf_block {
             Some(leaf_block) => leaf_block,
             None => self.state_store.with_read_tx(|tx| LeafBlock::get(tx))?,
@@ -312,18 +312,23 @@ where TConsensusSpec: ConsensusSpec
                 .is_leader_for_next_block(&self.validator_addr, &local_committee, leaf_block.height);
         debug!(
             target: LOG_TARGET,
-            "🔥 [on_beat] {} Is leader: {:?}, leaf_block: {}, local_committee: {}, must_propose: {}",
+            "🔥 [on_beat{}] {} Is leader: {:?}, leaf_block: {}, local_committee: {}",
+            if is_newview_propose { " (NEWVIEW)"} else { "" },
             self.validator_addr,
             is_leader,
             leaf_block,
             local_committee
                 .len(),
-            must_propose
         );
         if is_leader {
             self.on_propose
-                .handle(current_epoch, local_committee, leaf_block, must_propose)
+                .handle(current_epoch, local_committee, leaf_block, is_newview_propose)
                 .await?;
+        } else if is_newview_propose {
+            // We can make this a warm/error in future, but for now I want to be sure this never happens
+            panic!("propose_if_leader called with is_newview_propose=true but we're not the leader");
+        } else {
+            // Nothing to do - thanks Clippy
         }
         Ok(())
     }
diff --git a/dan_layer/consensus_tests/src/consensus.rs b/dan_layer/consensus_tests/src/consensus.rs
index b7b827320..78ad80f20 100644
--- a/dan_layer/consensus_tests/src/consensus.rs
+++ b/dan_layer/consensus_tests/src/consensus.rs
@@ -38,7 +38,7 @@ async fn single_transaction() {
     // First get transaction in the mempool
     test.send_transaction_to_all(Decision::Commit, 1, 1).await;
     test.wait_until_new_pool_count(1).await;
-    test.start_epoch(Epoch(0));
+    test.start_epoch(Epoch(0)).await;
 
     loop {
         test.on_block_committed().await;
@@ -66,7 +66,7 @@ async fn propose_blocks_with_queued_up_transactions_until_all_committed() {
         test.send_transaction_to_all(Decision::Commit, 1, 5).await;
     }
     test.wait_until_new_pool_count(10).await;
-    test.start_epoch(Epoch(0));
+    test.start_epoch(Epoch(0)).await;
 
     loop {
         test.on_block_committed().await;
@@ -96,7 +96,7 @@ async fn node_requests_missing_transaction_from_local_leader() {
             .await;
     }
     test.wait_until_new_pool_count_for_vn(10, TestAddress::new("2")).await;
-    test.start_epoch(Epoch(0));
+    test.start_epoch(Epoch(0)).await;
     loop {
         let (_, committed_height) = test.on_block_committed().await;
 
@@ -144,7 +144,7 @@ async fn propose_blocks_with_new_transactions_until_all_committed() {
     setup_logger();
     let mut test = Test::builder().add_committee(0, vec!["1"]).start().await;
     let mut remaining_txs = 10;
-    test.start_epoch(Epoch(0));
+    test.start_epoch(Epoch(0)).await;
     loop {
         if remaining_txs > 0 {
             test.send_transaction_to_all(Decision::Commit, 1, 5).await;
@@ -173,7 +173,7 @@ async fn multi_validator_propose_blocks_with_new_transactions_until_all_committe
         .start()
         .await;
     let mut remaining_txs = 10u32;
-    test.start_epoch(Epoch(0));
+    test.start_epoch(Epoch(0)).await;
     loop {
         if remaining_txs > 0 {
             test.send_transaction_to_all(Decision::Commit, 1, 5).await;
@@ -211,7 +211,7 @@ async fn multi_shard_propose_blocks_with_new_transactions_until_all_committed()
     }
 
     test.wait_all_have_at_least_n_new_transactions_in_pool(20).await;
-    test.start_epoch(Epoch(0));
+    test.start_epoch(Epoch(0)).await;
 
     loop {
         test.on_block_committed().await;
@@ -242,6 +242,7 @@ async fn multi_shard_propose_blocks_with_new_transactions_until_all_committed()
 async fn foreign_shard_decides_to_abort() {
     setup_logger();
     let mut test = Test::builder()
+        .with_test_timeout(Duration::from_secs(60))
         .add_committee(0, vec!["1", "3", "4"])
         .add_committee(1, vec!["2", "5", "6"])
         .start()
@@ -258,7 +259,7 @@ async fn foreign_shard_decides_to_abort() {
     assert_eq!(tx1.id(), tx2.id());
 
     test.wait_all_have_at_least_n_new_transactions_in_pool(1).await;
-    test.start_epoch(Epoch(0));
+    test.start_epoch(Epoch(0)).await;
 
     loop {
         test.on_block_committed().await;
@@ -315,7 +316,8 @@ async fn leader_failure_output_conflict() {
         .await;
 
     test.wait_all_have_at_least_n_new_transactions_in_pool(2).await;
-    test.start_epoch(Epoch(0));
+    tokio::time::sleep(Duration::from_secs(1)).await;
+    test.start_epoch(Epoch(0)).await;
 
     loop {
         test.on_block_committed().await;
@@ -360,7 +362,7 @@ async fn leader_failure_node_goes_down() {
         test.send_transaction_to_all(Decision::Commit, 1, 2).await;
     }
     test.wait_all_have_at_least_n_new_transactions_in_pool(10).await;
-    test.start_epoch(Epoch(0));
+    test.start_epoch(Epoch(0)).await;
 
     loop {
         let (_, committed_height) = test.on_block_committed().await;
@@ -380,7 +382,7 @@ async fn leader_failure_node_goes_down() {
             break;
         }
 
-        if committed_height > NodeHeight(20) {
+        if committed_height > NodeHeight(40) {
             panic!("Not all transaction committed after {} blocks", committed_height);
         }
     }
diff --git a/dan_layer/consensus_tests/src/support/epoch_manager.rs b/dan_layer/consensus_tests/src/support/epoch_manager.rs
index dac77d42f..3769f8b64 100644
--- a/dan_layer/consensus_tests/src/support/epoch_manager.rs
+++ b/dan_layer/consensus_tests/src/support/epoch_manager.rs
@@ -35,6 +35,11 @@ impl TestEpochManager {
         }
     }
 
+    pub async fn set_is_epoch_active(&self, is_epoch_active: bool) -> &Self {
+        self.inner.lock().await.is_epoch_active = is_epoch_active;
+        self
+    }
+
     pub async fn state_lock(&self) -> MutexGuard<TestEpochManagerState> {
         self.inner.lock().await
     }
@@ -214,7 +219,7 @@ impl Default for TestEpochManagerState {
         Self {
             current_epoch: Epoch(0),
             validator_shards: HashMap::new(),
-            is_epoch_active: true,
+            is_epoch_active: false,
             committees: HashMap::new(),
             address_bucket: HashMap::new(),
         }
diff --git a/dan_layer/consensus_tests/src/support/harness.rs b/dan_layer/consensus_tests/src/support/harness.rs
index 3d7ca1f08..7f3899b1e 100644
--- a/dan_layer/consensus_tests/src/support/harness.rs
+++ b/dan_layer/consensus_tests/src/support/harness.rs
@@ -10,14 +10,14 @@ use futures::{stream::FuturesUnordered, StreamExt};
 use tari_consensus::hotstuff::HotstuffEvent;
 use tari_dan_common_types::{committee::Committee, shard_bucket::ShardBucket, Epoch, NodeHeight};
 use tari_dan_storage::{
-    consensus_models::{Block, BlockId, Decision, TransactionPoolStage},
+    consensus_models::{Block, BlockId, Decision, TransactionPoolStage, TransactionRecord},
     StateStore,
     StateStoreReadTransaction,
 };
 use tari_epoch_manager::{EpochManagerEvent, EpochManagerReader};
 use tari_shutdown::{Shutdown, ShutdownSignal};
 use tari_transaction::TransactionId;
-use tokio::{task, time::timeout};
+use tokio::task;
 
 use crate::support::{
     address::TestAddress,
@@ -35,7 +35,7 @@ pub struct Test {
     _leader_strategy: RoundRobinLeaderStrategy,
     epoch_manager: TestEpochManager,
     shutdown: Shutdown,
-    timeout: Duration,
+    timeout: Option<Duration>,
 }
 
 impl Test {
@@ -74,9 +74,13 @@ impl Test {
 
     pub async fn on_block_committed(&mut self) -> (BlockId, NodeHeight) {
         loop {
-            let event = timeout(self.timeout, self.on_hotstuff_event())
-                .await
-                .unwrap_or_else(|_| panic!("Timeout waiting for Hotstuff event"));
+            let event = if let Some(timeout) = self.timeout {
+                tokio::time::timeout(timeout, self.on_hotstuff_event())
+                    .await
+                    .unwrap_or_else(|_| panic!("Timeout waiting for Hotstuff event"))
+            } else {
+                self.on_hotstuff_event().await
+            };
             match event {
                 HotstuffEvent::BlockCommitted { block_id, height } => return (block_id, height),
                 HotstuffEvent::Failure { message } => panic!("Consensus failure: {}", message),
@@ -92,8 +96,9 @@ impl Test {
         &mut self.network
     }
 
-    pub fn start_epoch(&mut self, epoch: Epoch) {
+    pub async fn start_epoch(&mut self, epoch: Epoch) {
         for validator in self.validators.values() {
+            validator.epoch_manager.set_is_epoch_active(true).await;
             // Fire off initial epoch change event so that the pacemaker starts
             validator
                 .tx_epoch_events
@@ -233,28 +238,25 @@ impl Test {
             let decisions = self.validators.values().map(|v| {
                 let decisions = v
                     .state_store
-                    .with_read_tx(|tx| Block::get_tip(tx))
+                    .with_read_tx(|tx| TransactionRecord::get(tx, transaction_id))
                     .unwrap()
-                    .commands()
-                    .iter()
-                    .filter(|cmd| cmd.transaction_id() == transaction_id)
-                    .map(|cmd| cmd.decision())
-                    .collect::<Vec<_>>();
+                    .final_decision();
                 (v.address.clone(), decisions)
             });
-            for (addr, decisions) in decisions {
-                let all_match = decisions.iter().all(|d| *d == expected_decision);
-                if all_match && attempts < 5 {
+            for (addr, decision) in decisions {
+                if decision.is_none() && attempts < 5 {
                     attempts += 1;
                     // Send this task to the back of the queue and try again after other tasks have executed
                     // to allow validators to catch up
                     task::yield_now().await;
                     continue 'outer;
                 }
-                assert!(
-                    all_match,
-                    "Expected {} but validator {} has decision(s) {:?} for transaction {}",
-                    expected_decision, addr, decisions, transaction_id
+
+                let decision = decision.unwrap_or_else(|| panic!("VN {} did not make a decision in time", addr));
+                assert_eq!(
+                    decision, expected_decision,
+                    "Expected {} but validator {} has decision {:?} for transaction {}",
+                    expected_decision, addr, decision, transaction_id
                 );
             }
             break;
@@ -280,7 +282,7 @@ impl Test {
 pub struct TestBuilder {
     committees: HashMap<ShardBucket, Committee<TestAddress>>,
     sql_address: String,
-    timeout: Duration,
+    timeout: Option<Duration>,
     debug_sql_file: Option<String>,
 }
 
@@ -289,11 +291,17 @@ impl TestBuilder {
         Self {
             committees: HashMap::new(),
             sql_address: ":memory:".to_string(),
-            timeout: Duration::from_secs(10),
+            timeout: Some(Duration::from_secs(10)),
             debug_sql_file: None,
         }
     }
 
+    #[allow(dead_code)]
+    pub fn disable_timeout(&mut self) -> &mut Self {
+        self.timeout = None;
+        self
+    }
+
     #[allow(dead_code)]
     pub fn debug_sql<P: Into<String>>(&mut self, path: P) -> &mut Self {
         self.debug_sql_file = Some(path.into());
@@ -307,7 +315,7 @@ impl TestBuilder {
     }
 
     pub fn with_test_timeout(&mut self, timeout: Duration) -> &mut Self {
-        self.timeout = timeout;
+        self.timeout = Some(timeout);
         self
     }
 
diff --git a/dan_layer/consensus_tests/src/support/validator/builder.rs b/dan_layer/consensus_tests/src/support/validator/builder.rs
index 6be79e043..a1135d9e2 100644
--- a/dan_layer/consensus_tests/src/support/validator/builder.rs
+++ b/dan_layer/consensus_tests/src/support/validator/builder.rs
@@ -6,7 +6,7 @@ use tari_dan_common_types::{shard_bucket::ShardBucket, ShardId};
 use tari_dan_storage::consensus_models::TransactionPool;
 use tari_shutdown::ShutdownSignal;
 use tari_state_store_sqlite::SqliteStateStore;
-use tokio::sync::{broadcast, mpsc};
+use tokio::sync::{broadcast, mpsc, watch};
 
 use crate::support::{
     address::TestAddress,
@@ -103,11 +103,13 @@ impl ValidatorBuilder {
             shutdown_signal.clone(),
         );
 
+        let (tx_current_state, _) = watch::channel(Default::default());
         let context = ConsensusWorkerContext {
             epoch_manager,
             epoch_events: rx_epoch_events,
             hotstuff: worker,
             state_sync: AlwaysSyncedSyncManager,
+            tx_current_state,
         };
 
         let mut worker = ConsensusWorker::new(shutdown_signal);
diff --git a/dan_layer/engine/src/transaction/processor.rs b/dan_layer/engine/src/transaction/processor.rs
index 4f68520b0..94af73998 100644
--- a/dan_layer/engine/src/transaction/processor.rs
+++ b/dan_layer/engine/src/transaction/processor.rs
@@ -123,8 +123,10 @@ impl<TTemplateProvider: TemplateProvider<Template = LoadedTemplate> + 'static> T
                 // Checkpoint the tracker state after the fee instructions have been executed in case of transaction
                 // failure.
                 if let Err(err) = runtime.interface().fee_checkpoint() {
-                    let mut finalize =
-                        FinalizeResult::reject(transaction_hash, RejectReason::ExecutionFailure(err.to_string()));
+                    let mut finalize = FinalizeResult::new_rejectted(
+                        transaction_hash,
+                        RejectReason::ExecutionFailure(err.to_string()),
+                    );
                     finalize.execution_results = execution_results;
                     return Ok(ExecuteResult {
                         fee_receipt: None,
@@ -137,7 +139,10 @@ impl<TTemplateProvider: TemplateProvider<Template = LoadedTemplate> + 'static> T
             Err(err) => {
                 return Ok(ExecuteResult {
                     fee_receipt: None,
-                    finalize: FinalizeResult::reject(transaction_hash, RejectReason::ExecutionFailure(err.to_string())),
+                    finalize: FinalizeResult::new_rejectted(
+                        transaction_hash,
+                        RejectReason::ExecutionFailure(err.to_string()),
+                    ),
                     transaction_failure: Some(RejectReason::FeeTransactionFailed),
                 });
             },
diff --git a/dan_layer/engine_types/src/commit_result.rs b/dan_layer/engine_types/src/commit_result.rs
index b6756fb25..17dc400e2 100644
--- a/dan_layer/engine_types/src/commit_result.rs
+++ b/dan_layer/engine_types/src/commit_result.rs
@@ -113,7 +113,7 @@ impl FinalizeResult {
         }
     }
 
-    pub fn reject(transaction_hash: Hash, reason: RejectReason) -> Self {
+    pub fn new_rejectted(transaction_hash: Hash, reason: RejectReason) -> Self {
         Self {
             transaction_hash,
             logs: vec![],
@@ -124,9 +124,20 @@ impl FinalizeResult {
         }
     }
 
+    pub fn reject(&self) -> Option<&RejectReason> {
+        match self.result {
+            TransactionResult::Accept(_) => None,
+            TransactionResult::Reject(ref reason) => Some(reason),
+        }
+    }
+
     pub fn is_accept(&self) -> bool {
         matches!(self.result, TransactionResult::Accept(_))
     }
+
+    pub fn is_reject(&self) -> bool {
+        matches!(self.result, TransactionResult::Reject(_))
+    }
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
diff --git a/dan_layer/state_store_sqlite/Cargo.toml b/dan_layer/state_store_sqlite/Cargo.toml
index 438bcff2e..f9059c3ca 100644
--- a/dan_layer/state_store_sqlite/Cargo.toml
+++ b/dan_layer/state_store_sqlite/Cargo.toml
@@ -26,4 +26,4 @@ thiserror = "1.0"
 time = "0.3"
 
 [dev-dependencies]
-rand = "0.8"
+rand = "0.8"
\ No newline at end of file
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 dc0e9e989..598a397e4 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
@@ -16,7 +16,7 @@ create table blocks
 (
     id               integer   not null primary key AUTOINCREMENT,
     block_id         text      not NULL,
-    parent_block_id  text      NULL,
+    parent_block_id  text      not NULL,
     height           bigint    not NULL,
     epoch            bigint    not NULL,
     proposed_by      text      not NULL,
@@ -142,11 +142,11 @@ create table transaction_pool
 (
     id                integer   not null primary key AUTOINCREMENT,
     transaction_id    text      not null,
-    involved_shards   text      not null,
     original_decision text      not null,
     local_decision    text      null,
     remote_decision   text      null,
     evidence          text      not null,
+    remote_evidence   text      null,
     transaction_fee   bigint    not null,
     leader_fee        bigint    not null,
     stage             text      not null,
@@ -159,19 +159,21 @@ create table transaction_pool
 create unique index transaction_pool_uniq_idx_transaction_id on transaction_pool (transaction_id);
 create index transaction_pool_idx_is_ready on transaction_pool (is_ready);
 
-create table transaction_pool_status
+create table transaction_pool_state_updates
 (
     id             integer   not null primary key AUTOINCREMENT,
     block_id       text      not null,
     block_height   bigint    not null,
     transaction_id text      not null,
     stage          text      not null,
+    evidence       text      not null,
     is_ready       boolean   not null,
+    local_decision text      not null,
     created_at     timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
     FOREIGN KEY (block_id) REFERENCES blocks (block_id),
     FOREIGN KEY (transaction_id) REFERENCES transactions (transaction_id)
 );
-create index transaction_pool_idx_block_id_transaction_id on transaction_pool_status (block_id, transaction_id);
+create unique index transaction_pool_uniq_block_id_transaction_id on transaction_pool_state_updates (block_id, transaction_id);
 
 create table locked_outputs
 (
@@ -214,3 +216,60 @@ CREATE TABLE missing_transactions
     is_awaiting_execution boolean   not NULL,
     created_at            timestamp not NULL DEFAULT CURRENT_TIMESTAMP
 );
+
+-- Debug Triggers
+CREATE TABLE transaction_pool_history
+(
+    history_id        INTEGER PRIMARY KEY,
+    id                integer   not null,
+    transaction_id    text      not null,
+    original_decision text      not null,
+    local_decision    text      null,
+    remote_decision   text      null,
+    evidence          text      not null,
+    transaction_fee   bigint    not null,
+    leader_fee        bigint    not null,
+    stage             text      not null,
+    new_stage         text      not null,
+    is_ready          boolean   not null,
+    new_is_ready      boolean   not null,
+    updated_at        timestamp NOT NULL,
+    created_at        timestamp NOT NULL,
+    change_time       DATETIME DEFAULT (STRFTIME('%Y-%m-%d %H:%M:%f', 'NOW'))
+);
+
+CREATE TRIGGER copy_transaction_pool_history
+    AFTER UPDATE
+    ON transaction_pool
+    FOR EACH ROW
+BEGIN
+    INSERT INTO transaction_pool_history (id,
+                                          transaction_id,
+                                          original_decision,
+                                          local_decision,
+                                          remote_decision,
+                                          evidence,
+                                          transaction_fee,
+                                          leader_fee,
+                                          stage,
+                                          new_stage,
+                                          is_ready,
+                                          new_is_ready,
+                                          updated_at,
+                                          created_at)
+    VALUES (OLD.id,
+            OLD.transaction_id,
+            OLD.original_decision,
+            OLD.local_decision,
+            OLD.remote_decision,
+            OLD.evidence,
+            OLD.transaction_fee,
+            OLD.leader_fee,
+            OLD.stage,
+            NEW.stage,
+            OLD.is_ready,
+            NEW.is_ready,
+            OLD.updated_at,
+            OLD.created_at);
+END;
+
diff --git a/dan_layer/state_store_sqlite/src/reader.rs b/dan_layer/state_store_sqlite/src/reader.rs
index 80e2264ad..dc3fc409a 100644
--- a/dan_layer/state_store_sqlite/src/reader.rs
+++ b/dan_layer/state_store_sqlite/src/reader.rs
@@ -1,10 +1,16 @@
 //   Copyright 2023 The Tari Project
 //   SPDX-License-Identifier: BSD-3-Clause
 
-use std::{borrow::Borrow, collections::HashSet, marker::PhantomData, ops::RangeInclusive};
+use std::{
+    borrow::Borrow,
+    collections::{HashMap, HashSet},
+    marker::PhantomData,
+    ops::RangeInclusive,
+};
 
 use bigdecimal::{BigDecimal, ToPrimitive};
 use diesel::{
+    query_builder::SqlQuery,
     sql_query,
     sql_types::{BigInt, Text},
     BoolExpressionMethods,
@@ -32,6 +38,8 @@ use tari_dan_storage::{
         LockedBlock,
         QcId,
         QuorumCertificate,
+        SubstateLockFlag,
+        SubstateLockState,
         SubstateRecord,
         TransactionPoolRecord,
         TransactionPoolStage,
@@ -79,6 +87,148 @@ impl<'a, TAddr> SqliteStateStoreReadTransaction<'a, TAddr> {
     }
 }
 
+impl<'a, TAddr: NodeAddressable + Serialize + DeserializeOwned> SqliteStateStoreReadTransaction<'a, TAddr> {
+    pub(super) fn get_transaction_atom_state_updates_between_blocks<'i, ITx>(
+        &mut self,
+        from_block_id: &BlockId,
+        to_block_id: &BlockId,
+        transaction_ids: ITx,
+    ) -> Result<HashMap<String, sql_models::TransactionPoolStateUpdate>, SqliteStorageError>
+    where
+        ITx: Iterator<Item = &'i str> + ExactSizeIterator,
+    {
+        if transaction_ids.len() == 0 {
+            return Ok(HashMap::new());
+        }
+
+        let applicable_block_ids = self.get_block_ids_that_change_state_between(from_block_id, to_block_id)?;
+
+        debug!(
+            target: LOG_TARGET,
+            "get_transaction_atom_state_updates_between_blocks: from_block_id={}, to_block_id={}, len(applicable_block_ids)={}",
+            from_block_id,
+            to_block_id,
+            applicable_block_ids.len());
+
+        if applicable_block_ids.is_empty() {
+            return Ok(HashMap::new());
+        }
+
+        self.create_transaction_atom_updates_query(transaction_ids, applicable_block_ids.iter().map(|s| s.as_str()))
+            .load_iter::<sql_models::TransactionPoolStateUpdate, _>(self.connection())
+            .map_err(|e| SqliteStorageError::DieselError {
+                operation: "transaction_pool_get_many_ready",
+                source: e,
+            })?
+            .map(|update| update.map(|u| (u.transaction_id.clone(), u)))
+            .collect::<diesel::QueryResult<HashMap<_, _>>>()
+            .map_err(|e| SqliteStorageError::DieselError {
+                operation: "transaction_pool_get_many_ready",
+                source: e,
+            })
+    }
+
+    /// Creates a query to select the latest transaction pool state updates for the given transaction ids and block ids.
+    /// WARNING: This method does not protect against SQL-injection, Be sure that the transaction ids and block ids
+    /// strings are what they are meant to be.
+    fn create_transaction_atom_updates_query<
+        'i1,
+        'i2,
+        IBlk: Iterator<Item = &'i1 str> + ExactSizeIterator,
+        ITx: Iterator<Item = &'i2 str> + ExactSizeIterator,
+    >(
+        &mut self,
+        transaction_ids: ITx,
+        block_ids: IBlk,
+    ) -> SqlQuery {
+        // Unfortunate hack. Binding array types in diesel is only supported for postgres.
+        sql_query(format!(
+            r#"
+                 WITH RankedResults AS (
+                    SELECT
+                        tpsu.*,
+                        ROW_NUMBER() OVER (PARTITION BY tpsu.transaction_id ORDER BY tpsu.block_height DESC) AS `rank`
+                    FROM
+                        transaction_pool_state_updates AS tpsu
+                    WHERE
+                        tpsu.block_id in ({})
+                    AND tpsu.transaction_id in ({})
+                )
+                SELECT
+                    id,
+                    block_id,
+                    block_height,
+                    transaction_id,
+                    stage,
+                    evidence,
+                    is_ready,
+                    local_decision,
+                    created_at
+                FROM
+                    RankedResults
+                WHERE
+                    rank = 1;
+                "#,
+            self.sql_frag_for_in_statement(block_ids, BlockId::byte_size() * 2),
+            self.sql_frag_for_in_statement(transaction_ids, TransactionId::byte_size() * 2),
+        ))
+    }
+
+    fn sql_frag_for_in_statement<'i, I: Iterator<Item = &'i str> + ExactSizeIterator>(
+        &self,
+        values: I,
+        item_size: usize,
+    ) -> String {
+        let len = values.len();
+        let mut sql_frag = String::with_capacity(len * item_size + len * 3 + len - 1);
+        for (i, value) in values.enumerate() {
+            sql_frag.push('"');
+            sql_frag.push_str(value);
+            sql_frag.push('"');
+            if i < len - 1 {
+                sql_frag.push(',');
+            }
+        }
+        sql_frag
+    }
+
+    fn get_block_ids_that_change_state_between(
+        &mut self,
+        start_block: &BlockId,
+        end_block: &BlockId,
+    ) -> Result<Vec<String>, SqliteStorageError> {
+        let applicable_block_ids = sql_query(
+            r#"
+            WITH RECURSIVE tree(bid, parent, is_dummy, command_count) AS (
+                SELECT block_id, parent_block_id, is_dummy, command_count FROM blocks where block_id = ?
+            UNION ALL
+                SELECT block_id, parent_block_id, blocks.is_dummy, blocks.command_count
+                FROM blocks JOIN tree ON
+                    block_id = tree.parent
+                    AND tree.bid != ?
+                LIMIT 1000
+            )
+            SELECT bid FROM tree where is_dummy = 0 AND command_count > 0"#,
+        )
+        .bind::<Text, _>(serialize_hex(end_block))
+        .bind::<Text, _>(serialize_hex(start_block))
+        .load_iter::<BlockIdSqlValue, _>(self.connection())
+        .map_err(|e| SqliteStorageError::DieselError {
+            operation: "get_block_ids_that_change_state_between",
+            source: e,
+        })?;
+
+        applicable_block_ids
+            .map(|b| {
+                b.map(|b| b.bid).map_err(|e| SqliteStorageError::DieselError {
+                    operation: "get_block_ids_that_change_state_between",
+                    source: e,
+                })
+            })
+            .collect()
+    }
+}
+
 impl<TAddr: NodeAddressable + Serialize + DeserializeOwned> StateStoreReadTransaction
     for SqliteStateStoreReadTransaction<'_, TAddr>
 {
@@ -759,32 +909,107 @@ impl<TAddr: NodeAddressable + Serialize + DeserializeOwned> StateStoreReadTransa
         Vote::try_from(vote)
     }
 
-    fn transaction_pool_get(&mut self, transaction_id: &TransactionId) -> Result<TransactionPoolRecord, StorageError> {
+    fn transaction_pool_get(
+        &mut self,
+        from_block_id: &BlockId,
+        to_block_id: &BlockId,
+        transaction_id: &TransactionId,
+    ) -> Result<TransactionPoolRecord, StorageError> {
         use crate::schema::transaction_pool;
 
-        transaction_pool::table
-            .filter(transaction_pool::transaction_id.eq(serialize_hex(transaction_id)))
+        let transaction_id = serialize_hex(transaction_id);
+        let mut updates = self.get_transaction_atom_state_updates_between_blocks(
+            from_block_id,
+            to_block_id,
+            std::iter::once(transaction_id.as_str()),
+        )?;
+
+        debug!(
+            target: LOG_TARGET,
+            "transaction_pool_get: from_block_id={}, to_block_id={}, transaction_id={}, updates={}",
+            from_block_id,
+            to_block_id,
+            transaction_id,
+            updates.len()
+        );
+
+        let rec = transaction_pool::table
+            .filter(transaction_pool::transaction_id.eq(&transaction_id))
             .first::<sql_models::TransactionPoolRecord>(self.connection())
             .map_err(|e| SqliteStorageError::DieselError {
                 operation: "transaction_pool_get",
                 source: e,
-            })?
-            .try_into()
+            })?;
+
+        rec.try_convert(updates.remove(&transaction_id))
+    }
+
+    fn transaction_pool_exists(&mut self, transaction_id: &TransactionId) -> Result<bool, StorageError> {
+        use crate::schema::transaction_pool;
+
+        let count = transaction_pool::table
+            .count()
+            .filter(transaction_pool::transaction_id.eq(serialize_hex(transaction_id)))
+            .first::<i64>(self.connection())
+            .map_err(|e| SqliteStorageError::DieselError {
+                operation: "transaction_pool_get",
+                source: e,
+            })?;
+
+        Ok(count > 0)
     }
 
     fn transaction_pool_get_many_ready(&mut self, max_txs: usize) -> Result<Vec<TransactionPoolRecord>, StorageError> {
         use crate::schema::transaction_pool;
 
-        transaction_pool::table
-            .filter(transaction_pool::is_ready.eq(true))
-            .limit(max_txs as i64)
+        let ready_txs = transaction_pool::table
+            // .filter(transaction_pool::is_ready.eq(true))
+            // .limit(max_txs as i64)
             .get_results::<sql_models::TransactionPoolRecord>(self.connection())
             .map_err(|e| SqliteStorageError::DieselError {
                 operation: "transaction_pool_get_many_ready",
                 source: e,
-            })?
+            })?;
+
+        if ready_txs.is_empty() {
+            return Ok(Vec::new());
+        }
+
+        // Fetch all applicable block ids between the locked block and the given block
+        let locked = self.locked_block_get()?;
+        let leaf = self.leaf_block_get()?;
+
+        let mut updates = self.get_transaction_atom_state_updates_between_blocks(
+            &locked.block_id,
+            &leaf.block_id,
+            ready_txs.iter().map(|s| s.transaction_id.as_str()),
+        )?;
+
+        debug!(
+            target: LOG_TARGET,
+            "transaction_pool_get: from_block_id={}, to_block_id={}, len(ready_txs)={}, updates={}",
+            locked.block_id,
+            leaf.block_id,
+            ready_txs.len(),
+            updates.len()
+        );
+
+        ready_txs
             .into_iter()
-            .map(TryInto::try_into)
+            .filter_map(|rec| {
+                let maybe_update = updates.remove(&rec.transaction_id);
+                match rec.try_convert(maybe_update) {
+                    Ok(rec) => {
+                        if rec.is_ready() {
+                            Some(Ok(rec))
+                        } else {
+                            None
+                        }
+                    },
+                    Err(e) => Some(Err(e)),
+                }
+            })
+            .take(max_txs)
             .collect()
     }
 
@@ -974,6 +1199,77 @@ impl<TAddr: NodeAddressable + Serialize + DeserializeOwned> StateStoreReadTransa
 
         Ok(substates)
     }
+
+    fn substates_check_lock_many<'a, I: IntoIterator<Item = &'a ShardId>>(
+        &mut self,
+        objects: I,
+        lock_flag: SubstateLockFlag,
+    ) -> Result<SubstateLockState, StorageError> {
+        use crate::schema::substates;
+
+        // Lock unique shards
+        let objects: HashSet<String> = objects.into_iter().map(serialize_hex).collect();
+
+        let locked_details = substates::table
+            .select((substates::is_locked_w, substates::destroyed_by_transaction))
+            .filter(substates::shard_id.eq_any(&objects))
+            .get_results::<(bool, Option<String>)>(self.connection())
+            .map_err(|e| SqliteStorageError::DieselError {
+                operation: "transactions_try_lock_many",
+                source: e,
+            })?;
+        if locked_details.len() < objects.len() {
+            return Err(SqliteStorageError::NotAllSubstatesFound {
+                operation: "substates_try_lock_all",
+                details: format!(
+                    "{:?}: Found {} substates, but {} were requested",
+                    lock_flag,
+                    locked_details.len(),
+                    objects.len()
+                ),
+            }
+            .into());
+        }
+
+        if locked_details.iter().any(|(w, _)| *w) {
+            return Ok(SubstateLockState::SomeAlreadyWriteLocked);
+        }
+
+        if locked_details.iter().any(|(_, downed)| downed.is_some()) {
+            return Ok(SubstateLockState::SomeDestroyed);
+        }
+
+        Ok(SubstateLockState::LockAcquired)
+    }
+
+    // -------------------------------- LockedOutputs -------------------------------- //
+    fn locked_outputs_check_all<I, B>(&mut self, output_shards: I) -> Result<SubstateLockState, StorageError>
+    where
+        I: IntoIterator<Item = B>,
+        B: Borrow<ShardId>,
+    {
+        use crate::schema::locked_outputs;
+
+        let outputs_hex = output_shards
+            .into_iter()
+            .map(|shard_id| serialize_hex(shard_id.borrow()))
+            .collect::<Vec<_>>();
+
+        let has_conflict = locked_outputs::table
+            .count()
+            .filter(locked_outputs::shard_id.eq_any(outputs_hex))
+            .first::<i64>(self.connection())
+            .map_err(|e| SqliteStorageError::DieselError {
+                operation: "locked_outputs_check_all",
+                source: e,
+            })?;
+
+        if has_conflict > 0 {
+            Ok(SubstateLockState::SomeAlreadyWriteLocked)
+        } else {
+            Ok(SubstateLockState::LockAcquired)
+        }
+    }
 }
 
 #[derive(QueryableByName)]
@@ -981,3 +1277,9 @@ struct Count {
     #[diesel(sql_type = diesel::sql_types::BigInt)]
     pub count: i64,
 }
+
+#[derive(QueryableByName)]
+struct BlockIdSqlValue {
+    #[diesel(sql_type = diesel::sql_types::Text)]
+    pub bid: String,
+}
diff --git a/dan_layer/state_store_sqlite/src/schema.rs b/dan_layer/state_store_sqlite/src/schema.rs
index 06cbf0b1b..29ea34bd3 100644
--- a/dan_layer/state_store_sqlite/src/schema.rs
+++ b/dan_layer/state_store_sqlite/src/schema.rs
@@ -142,11 +142,11 @@ diesel::table! {
     transaction_pool (id) {
         id -> Integer,
         transaction_id -> Text,
-        involved_shards -> Text,
         original_decision -> Text,
         local_decision -> Nullable<Text>,
         remote_decision -> Nullable<Text>,
         evidence -> Text,
+        remote_evidence -> Nullable<Text>,
         transaction_fee -> BigInt,
         leader_fee -> BigInt,
         stage -> Text,
@@ -158,13 +158,36 @@ diesel::table! {
 }
 
 diesel::table! {
-    transaction_pool_status (id) {
+    transaction_pool_history (history_id) {
+        history_id -> Nullable<Integer>,
+        id -> Integer,
+        transaction_id -> Text,
+        original_decision -> Text,
+        local_decision -> Nullable<Text>,
+        remote_decision -> Nullable<Text>,
+        evidence -> Text,
+        transaction_fee -> BigInt,
+        leader_fee -> BigInt,
+        stage -> Text,
+        new_stage -> Text,
+        is_ready -> Bool,
+        new_is_ready -> Bool,
+        updated_at -> Timestamp,
+        created_at -> Timestamp,
+        change_time -> Nullable<Timestamp>,
+    }
+}
+
+diesel::table! {
+    transaction_pool_state_updates (id) {
         id -> Integer,
         block_id -> Text,
         block_height -> BigInt,
         transaction_id -> Text,
         stage -> Text,
+        evidence -> Text,
         is_ready -> Bool,
+        local_decision -> Text,
         created_at -> Timestamp,
     }
 }
@@ -217,7 +240,8 @@ diesel::allow_tables_to_appear_in_same_query!(
     quorum_certificates,
     substates,
     transaction_pool,
-    transaction_pool_status,
+    transaction_pool_history,
+    transaction_pool_state_updates,
     transactions,
     votes,
 );
diff --git a/dan_layer/state_store_sqlite/src/sql_models/transaction_pool.rs b/dan_layer/state_store_sqlite/src/sql_models/transaction_pool.rs
index 041ab2a5f..21f75cc7c 100644
--- a/dan_layer/state_store_sqlite/src/sql_models/transaction_pool.rs
+++ b/dan_layer/state_store_sqlite/src/sql_models/transaction_pool.rs
@@ -1,8 +1,12 @@
 //    Copyright 2023 The Tari Project
 //    SPDX-License-Identifier: BSD-3-Clause
 
-use diesel::Queryable;
-use tari_dan_storage::{consensus_models, consensus_models::TransactionAtom, StorageError};
+use diesel::{Queryable, QueryableByName};
+use tari_dan_storage::{
+    consensus_models,
+    consensus_models::{Evidence, TransactionAtom},
+    StorageError,
+};
 use time::PrimitiveDateTime;
 
 use crate::serialization::{deserialize_hex_try_from, deserialize_json, parse_from_string};
@@ -11,48 +15,76 @@ use crate::serialization::{deserialize_hex_try_from, deserialize_json, parse_fro
 pub struct TransactionPoolRecord {
     pub id: i32,
     pub transaction_id: String,
-    pub involved_shards: String,
     pub original_decision: String,
     pub local_decision: Option<String>,
     pub remote_decision: Option<String>,
     pub evidence: String,
+    pub remote_evidence: Option<String>,
     pub transaction_fee: i64,
     pub leader_fee: i64,
     pub stage: String,
+    // TODO: This is the last stage update, but does not reflect the actual stage (which comes from the
+    //       transaction_pool_state_updates table). This is kind of a hack to make transaction_pool_count work
+    //       and should not given to TransactionPoolRecord::load.
     pub pending_stage: Option<String>,
     pub is_ready: bool,
     pub updated_at: PrimitiveDateTime,
     pub created_at: PrimitiveDateTime,
 }
 
-impl TryFrom<TransactionPoolRecord> for consensus_models::TransactionPoolRecord {
-    type Error = StorageError;
+impl TransactionPoolRecord {
+    pub fn try_convert(
+        mut self,
+        update: Option<TransactionPoolStateUpdate>,
+    ) -> Result<consensus_models::TransactionPoolRecord, StorageError> {
+        let mut evidence = deserialize_json::<Evidence>(&self.evidence)?;
+        let mut pending_stage = None;
+        if let Some(update) = update {
+            evidence.merge(deserialize_json::<Evidence>(&update.evidence)?);
+            self.is_ready = update.is_ready;
+            pending_stage = Some(parse_from_string(&update.stage)?);
+        }
 
-    fn try_from(value: TransactionPoolRecord) -> Result<Self, Self::Error> {
-        Ok(Self::load(
+        if let Some(ref remote_evidence) = self.remote_evidence {
+            evidence.merge(deserialize_json::<Evidence>(remote_evidence)?);
+        }
+
+        Ok(consensus_models::TransactionPoolRecord::load(
             TransactionAtom {
-                id: deserialize_hex_try_from(&value.transaction_id)?,
-                decision: parse_from_string(&value.original_decision)?,
-                evidence: deserialize_json(&value.evidence)?,
-                transaction_fee: value.transaction_fee as u64,
-                leader_fee: value.leader_fee as u64,
+                id: deserialize_hex_try_from(&self.transaction_id)?,
+                decision: parse_from_string(&self.original_decision)?,
+                evidence,
+                transaction_fee: self.transaction_fee as u64,
+                leader_fee: self.leader_fee as u64,
             },
-            parse_from_string(&value.stage)?,
-            value.pending_stage.as_deref().map(parse_from_string).transpose()?,
-            value.local_decision.as_deref().map(parse_from_string).transpose()?,
-            value.remote_decision.as_deref().map(parse_from_string).transpose()?,
-            value.is_ready,
+            parse_from_string(&self.stage)?,
+            pending_stage,
+            self.local_decision.as_deref().map(parse_from_string).transpose()?,
+            self.remote_decision.as_deref().map(parse_from_string).transpose()?,
+            self.is_ready,
         ))
     }
 }
 
-#[derive(Debug, Clone, Queryable)]
-pub struct TransactionPoolState {
+#[derive(Debug, Clone, Queryable, QueryableByName)]
+#[diesel(table_name = transaction_pool_state_updates)]
+pub struct TransactionPoolStateUpdate {
+    #[diesel(sql_type = diesel::sql_types::Integer)]
     pub id: i32,
+    #[diesel(sql_type = diesel::sql_types::Text)]
     pub block_id: String,
+    #[diesel(sql_type = diesel::sql_types::BigInt)]
     pub block_height: i64,
+    #[diesel(sql_type = diesel::sql_types::Text)]
     pub transaction_id: String,
+    #[diesel(sql_type = diesel::sql_types::Text)]
     pub stage: String,
+    #[diesel(sql_type = diesel::sql_types::Text)]
+    pub evidence: String,
+    #[diesel(sql_type = diesel::sql_types::Bool)]
     pub is_ready: bool,
+    #[diesel(sql_type = diesel::sql_types::Nullable<diesel::sql_types::Text>)]
+    pub local_decision: Option<String>,
+    #[diesel(sql_type = diesel::sql_types::Timestamp)]
     pub created_at: PrimitiveDateTime,
 }
diff --git a/dan_layer/state_store_sqlite/src/store.rs b/dan_layer/state_store_sqlite/src/store.rs
index 638941470..959138e72 100644
--- a/dan_layer/state_store_sqlite/src/store.rs
+++ b/dan_layer/state_store_sqlite/src/store.rs
@@ -51,6 +51,16 @@ impl<TAddr> SqliteStateStore<TAddr> {
             _addr: PhantomData,
         })
     }
+
+    pub fn foreign_keys_off(&self) -> Result<(), StorageError> {
+        sql_query("PRAGMA foreign_keys = OFF;")
+            .execute(&mut *self.connection.lock().unwrap())
+            .map_err(|source| SqliteStorageError::DieselError {
+                source,
+                operation: "set pragma",
+            })?;
+        Ok(())
+    }
 }
 
 // Manually implement the Debug implementation because `SqliteConnection` does not implement the Debug trait
diff --git a/dan_layer/state_store_sqlite/src/writer.rs b/dan_layer/state_store_sqlite/src/writer.rs
index f4f4430ec..49fbfe34e 100644
--- a/dan_layer/state_store_sqlite/src/writer.rs
+++ b/dan_layer/state_store_sqlite/src/writer.rs
@@ -7,15 +7,7 @@ use std::{
     ops::{Deref, DerefMut},
 };
 
-use diesel::{
-    AsChangeset,
-    ExpressionMethods,
-    NullableExpressionMethods,
-    OptionalExtension,
-    QueryDsl,
-    RunQueryDsl,
-    SqliteConnection,
-};
+use diesel::{AsChangeset, ExpressionMethods, OptionalExtension, QueryDsl, RunQueryDsl, SqliteConnection};
 use log::*;
 use tari_dan_common_types::{optional::Optional, Epoch, NodeAddressable, ShardId};
 use tari_dan_storage::{
@@ -38,6 +30,7 @@ use tari_dan_storage::{
         SubstateRecord,
         TransactionAtom,
         TransactionPoolStage,
+        TransactionPoolStatusUpdate,
         TransactionRecord,
         Vote,
     },
@@ -585,6 +578,42 @@ impl<TAddr: NodeAddressable> StateStoreWriteTransaction for SqliteStateStoreWrit
         Ok(())
     }
 
+    fn transactions_save_all<'a, I: IntoIterator<Item = &'a TransactionRecord>>(
+        &mut self,
+        txs: I,
+    ) -> Result<(), StorageError> {
+        use crate::schema::transactions;
+
+        let insert = txs
+            .into_iter()
+            .map(|rec| {
+                let transaction = rec.transaction();
+                Ok((
+                    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::outputs.eq(serialize_json(transaction.outputs())?),
+                    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()?),
+                ))
+            })
+            .collect::<Result<Vec<_>, StorageError>>()?;
+
+        diesel::insert_or_ignore_into(transactions::table)
+            .values(insert)
+            .execute(self.connection())
+            .map_err(|e| SqliteStorageError::DieselError {
+                operation: "transactions_insert",
+                source: e,
+            })?;
+
+        Ok(())
+    }
+
     fn transaction_pool_insert(
         &mut self,
         transaction: TransactionAtom,
@@ -595,9 +624,6 @@ impl<TAddr: NodeAddressable> StateStoreWriteTransaction for SqliteStateStoreWrit
 
         let insert = (
             transaction_pool::transaction_id.eq(serialize_hex(transaction.id)),
-            transaction_pool::involved_shards.eq(serialize_json(
-                &transaction.evidence.shards_iter().copied().collect::<Vec<_>>(),
-            )?),
             transaction_pool::original_decision.eq(transaction.decision.to_string()),
             transaction_pool::transaction_fee.eq(transaction.transaction_fee as i64),
             transaction_pool::leader_fee.eq(transaction.leader_fee as i64),
@@ -617,54 +643,121 @@ impl<TAddr: NodeAddressable> StateStoreWriteTransaction for SqliteStateStoreWrit
         Ok(())
     }
 
+    fn transaction_pool_add_pending_update(&mut self, update: TransactionPoolStatusUpdate) -> Result<(), StorageError> {
+        use crate::schema::{transaction_pool, transaction_pool_state_updates};
+
+        let transaction_id = serialize_hex(update.transaction_id());
+        let block_id = serialize_hex(update.block_id());
+        let values = (
+            transaction_pool_state_updates::block_id.eq(&block_id),
+            transaction_pool_state_updates::block_height.eq(update.block_height().as_u64() as i64),
+            transaction_pool_state_updates::transaction_id.eq(&transaction_id),
+            transaction_pool_state_updates::evidence.eq(serialize_json(update.evidence())?),
+            transaction_pool_state_updates::stage.eq(update.stage().to_string()),
+            transaction_pool_state_updates::local_decision.eq(update.local_decision().to_string()),
+            transaction_pool_state_updates::is_ready.eq(update.is_ready()),
+        );
+
+        // Check if update exists for block and transaction
+        let count = transaction_pool_state_updates::table
+            .count()
+            .filter(transaction_pool_state_updates::block_id.eq(&block_id))
+            .filter(transaction_pool_state_updates::transaction_id.eq(&transaction_id))
+            .first::<i64>(self.connection())
+            .map_err(|e| SqliteStorageError::DieselError {
+                operation: "transaction_pool_add_pending_update",
+                source: e,
+            })?;
+
+        if count == 0 {
+            diesel::insert_into(transaction_pool_state_updates::table)
+                .values(values)
+                .execute(self.connection())
+                .map_err(|e| SqliteStorageError::DieselError {
+                    operation: "transaction_pool_add_pending_update",
+                    source: e,
+                })?;
+        } else {
+            diesel::update(transaction_pool_state_updates::table)
+                .filter(transaction_pool_state_updates::block_id.eq(&block_id))
+                .filter(transaction_pool_state_updates::transaction_id.eq(&transaction_id))
+                .set(values)
+                .execute(self.connection())
+                .map_err(|e| SqliteStorageError::DieselError {
+                    operation: "transaction_pool_add_pending_update",
+                    source: e,
+                })?;
+        }
+
+        // Set is_ready to the last value we set here. Bit of a hack to get has_uncommitted_transactions to return a
+        // more accurate value without querying the updates table
+        diesel::update(transaction_pool::table)
+            .filter(transaction_pool::transaction_id.eq(&transaction_id))
+            .set((
+                transaction_pool::is_ready.eq(update.is_ready()),
+                transaction_pool::pending_stage.eq(update.stage().to_string()),
+            ))
+            .execute(self.connection())
+            .map_err(|e| SqliteStorageError::DieselError {
+                operation: "transaction_pool_add_pending_update",
+                source: e,
+            })?;
+
+        Ok(())
+    }
+
     fn transaction_pool_update(
         &mut self,
         transaction_id: &TransactionId,
-        evidence: Option<&Evidence>,
-        pending_stage: Option<Option<TransactionPoolStage>>,
         local_decision: Option<Decision>,
         remote_decision: Option<Decision>,
-        is_ready: Option<bool>,
+        remote_evidence: Option<&Evidence>,
     ) -> Result<(), StorageError> {
         use crate::schema::transaction_pool;
 
+        let transaction_id = serialize_hex(transaction_id);
+
         #[derive(AsChangeset)]
         #[diesel(table_name=transaction_pool)]
         struct Changes {
-            evidence: Option<String>,
-            pending_stage: Option<Option<String>>,
-            local_decision: Option<String>,
-            remote_decision: Option<String>,
-            is_ready: Option<bool>,
+            remote_evidence: Option<String>,
+            local_decision: Option<Option<String>>,
+            remote_decision: Option<Option<String>>,
             updated_at: PrimitiveDateTime,
         }
 
         let change_set = Changes {
-            evidence: evidence.map(serialize_json).transpose()?,
-            pending_stage: pending_stage.map(|s| s.map(|s| s.to_string())),
-            local_decision: local_decision.map(|d| d.to_string()),
-            remote_decision: remote_decision.map(|d| d.to_string()),
-            is_ready,
+            remote_evidence: remote_evidence.map(serialize_json).transpose()?,
+            local_decision: local_decision.map(|d| d.to_string()).map(Some),
+            remote_decision: remote_decision.map(|d| d.to_string()).map(Some),
             updated_at: now(),
         };
 
-        diesel::update(transaction_pool::table)
-            .filter(transaction_pool::transaction_id.eq(serialize_hex(transaction_id)))
+        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_update",
+                operation: "transaction_pool_set_remote_decision",
                 source: e,
             })?;
 
+        if num_affected == 0 {
+            return Err(StorageError::NotFound {
+                item: "transaction".to_string(),
+                key: transaction_id,
+            });
+        }
+
         Ok(())
     }
 
     fn transaction_pool_remove(&mut self, transaction_id: &TransactionId) -> Result<(), StorageError> {
-        use crate::schema::transaction_pool;
+        use crate::schema::{transaction_pool, transaction_pool_state_updates};
 
+        let transaction_id = serialize_hex(transaction_id);
         let num_affected = diesel::delete(transaction_pool::table)
-            .filter(transaction_pool::transaction_id.eq(serialize_hex(transaction_id)))
+            .filter(transaction_pool::transaction_id.eq(&transaction_id))
             .execute(self.connection())
             .map_err(|e| SqliteStorageError::DieselError {
                 operation: "transaction_pool_remove",
@@ -674,18 +767,28 @@ impl<TAddr: NodeAddressable> StateStoreWriteTransaction for SqliteStateStoreWrit
         if num_affected == 0 {
             return Err(StorageError::NotFound {
                 item: "transaction".to_string(),
-                key: transaction_id.to_string(),
+                key: transaction_id,
             });
         }
 
+        diesel::delete(transaction_pool_state_updates::table)
+            .filter(transaction_pool_state_updates::transaction_id.eq(transaction_id))
+            .execute(self.connection())
+            .map_err(|e| SqliteStorageError::DieselError {
+                operation: "transaction_pool_remove",
+                source: e,
+            })?;
+
         Ok(())
     }
 
     fn transaction_pool_set_all_transitions<'a, I: IntoIterator<Item = &'a TransactionId>>(
         &mut self,
+        locked_block: &LockedBlock,
+        new_locked_block: &LockedBlock,
         tx_ids: I,
     ) -> Result<(), StorageError> {
-        use crate::schema::transaction_pool;
+        use crate::schema::{transaction_pool, transaction_pool_state_updates};
 
         let tx_ids = tx_ids.into_iter().map(serialize_hex).collect::<Vec<_>>();
 
@@ -706,29 +809,43 @@ impl<TAddr: NodeAddressable> StateStoreWriteTransaction for SqliteStateStoreWrit
             .into());
         }
 
-        diesel::update(transaction_pool::table)
-            .filter(transaction_pool::transaction_id.eq_any(&tx_ids))
-            .filter(transaction_pool::pending_stage.is_not_null())
-            .set(transaction_pool::stage.eq(transaction_pool::pending_stage.assume_not_null()))
-            .execute(self.connection())
-            .map_err(|e| SqliteStorageError::DieselError {
-                operation: "transaction_pool_set_all_transitions",
-                source: e,
-            })?;
+        let updates = self.get_transaction_atom_state_updates_between_blocks(
+            locked_block.block_id(),
+            new_locked_block.block_id(),
+            tx_ids.iter().map(|s| s.as_str()),
+        )?;
 
-        diesel::update(transaction_pool::table)
-            .filter(transaction_pool::transaction_id.eq_any(&tx_ids))
-            .filter(transaction_pool::pending_stage.is_not_null())
-            .set((
-                transaction_pool::pending_stage.eq(None::<String>),
-                transaction_pool::updated_at.eq(now()),
-            ))
+        debug!(
+            target: LOG_TARGET,
+            "transaction_pool_set_all_transitions: locked_block={}, new_locked_block={}, {} transactions, {} updates", locked_block, new_locked_block, tx_ids.len(), updates.len()
+        );
+
+        diesel::delete(transaction_pool_state_updates::table)
+            .filter(transaction_pool_state_updates::transaction_id.eq_any(&tx_ids))
+            .filter(transaction_pool_state_updates::block_height.le(new_locked_block.height().as_u64() as i64))
             .execute(self.connection())
             .map_err(|e| SqliteStorageError::DieselError {
                 operation: "transaction_pool_set_all_transitions",
                 source: e,
             })?;
 
+        for update in updates.into_values() {
+            diesel::update(transaction_pool::table)
+                .filter(transaction_pool::transaction_id.eq(&update.transaction_id))
+                .set((
+                    transaction_pool::stage.eq(update.stage),
+                    transaction_pool::local_decision.eq(update.local_decision),
+                    transaction_pool::evidence.eq(update.evidence),
+                    transaction_pool::is_ready.eq(update.is_ready),
+                    transaction_pool::updated_at.eq(now()),
+                ))
+                .execute(self.connection())
+                .map_err(|e| SqliteStorageError::DieselError {
+                    operation: "transaction_pool_set_all_transitions",
+                    source: e,
+                })?;
+        }
+
         Ok(())
     }
 
diff --git a/dan_layer/state_store_sqlite/tests/tests.rs b/dan_layer/state_store_sqlite/tests/tests.rs
index 59ae232c5..26ed1a5ae 100644
--- a/dan_layer/state_store_sqlite/tests/tests.rs
+++ b/dan_layer/state_store_sqlite/tests/tests.rs
@@ -1,5 +1,127 @@
 //   Copyright 2023 The Tari Project
 //   SPDX-License-Identifier: BSD-3-Clause
 
-#[test]
-fn todo_write_some_tests() {}
+use rand::{rngs::OsRng, RngCore};
+use tari_dan_common_types::{Epoch, NodeHeight};
+use tari_dan_storage::{
+    consensus_models::{Block, Command, Decision, TransactionAtom, TransactionPoolStage, TransactionPoolStatusUpdate},
+    StateStore,
+    StateStoreReadTransaction,
+    StateStoreWriteTransaction,
+};
+use tari_state_store_sqlite::SqliteStateStore;
+use tari_transaction::TransactionId;
+
+fn create_db() -> SqliteStateStore<String> {
+    SqliteStateStore::connect(":memory:").unwrap()
+}
+
+fn create_tx_atom() -> TransactionAtom {
+    let mut bytes = [0u8; 32];
+    OsRng.fill_bytes(&mut bytes);
+    TransactionAtom {
+        id: TransactionId::new(bytes),
+        decision: Decision::Commit,
+        evidence: Default::default(),
+        transaction_fee: 0,
+        leader_fee: 0,
+    }
+}
+
+mod confirm_all_transitions {
+
+    use super::*;
+
+    #[test]
+    fn it_sets_pending_stage_to_stage() {
+        let db = create_db();
+        // Need FK=off because otherwise we'd have to create transactions for each in the pool
+        db.foreign_keys_off().unwrap();
+        let mut tx = db.create_write_tx().unwrap();
+
+        let atom1 = create_tx_atom();
+        let atom2 = create_tx_atom();
+        let atom3 = create_tx_atom();
+
+        let zero_block = Block::zero_block();
+        zero_block.insert(&mut tx).unwrap();
+        let block1 = Block::new(
+            *zero_block.id(),
+            zero_block.justify().clone(),
+            NodeHeight(1),
+            Epoch(0),
+            Default::default(),
+            // Need to have a command in, otherwise this block will not be included internally in the query because it
+            // cannot cause a state change without any commands
+            [Command::Prepare(atom1.clone())].into_iter().collect(),
+            Default::default(),
+        );
+        block1.insert(&mut tx).unwrap();
+
+        tx.transaction_pool_insert(atom1.clone(), TransactionPoolStage::New, false)
+            .unwrap();
+        tx.transaction_pool_insert(atom2.clone(), TransactionPoolStage::New, false)
+            .unwrap();
+        tx.transaction_pool_insert(atom3.clone(), TransactionPoolStage::New, false)
+            .unwrap();
+        let block_id = *block1.id();
+
+        tx.transaction_pool_add_pending_update(TransactionPoolStatusUpdate {
+            block_id,
+            block_height: NodeHeight(1),
+            transaction_id: atom1.id,
+            stage: TransactionPoolStage::LocalPrepared,
+            evidence: Default::default(),
+            is_ready: false,
+            local_decision: Decision::Commit,
+        })
+        .unwrap();
+        tx.transaction_pool_add_pending_update(TransactionPoolStatusUpdate {
+            block_id,
+            block_height: NodeHeight(1),
+            transaction_id: atom2.id,
+            stage: TransactionPoolStage::Prepared,
+            evidence: Default::default(),
+            is_ready: false,
+            local_decision: Decision::Commit,
+        })
+        .unwrap();
+        tx.transaction_pool_add_pending_update(TransactionPoolStatusUpdate {
+            block_id,
+            block_height: NodeHeight(1),
+            transaction_id: atom3.id,
+            stage: TransactionPoolStage::Prepared,
+            evidence: Default::default(),
+            is_ready: false,
+            local_decision: Decision::Commit,
+        })
+        .unwrap();
+
+        let rec = tx.transaction_pool_get(zero_block.id(), &block_id, &atom1.id).unwrap();
+        assert!(rec.stage().is_new());
+        assert!(rec.pending_stage().unwrap().is_local_prepared());
+
+        let rec = tx.transaction_pool_get(zero_block.id(), &block_id, &atom2.id).unwrap();
+        assert!(rec.stage().is_new());
+        assert!(rec.pending_stage().unwrap().is_prepared());
+
+        tx.transaction_pool_set_all_transitions(&zero_block.as_locked_block(), &block1.as_locked_block(), &[
+            atom1.id, atom3.id,
+        ])
+        .unwrap();
+
+        let rec = tx.transaction_pool_get(zero_block.id(), &block_id, &atom1.id).unwrap();
+        assert!(rec.stage().is_local_prepared());
+        assert!(rec.pending_stage().is_none());
+
+        let rec = tx.transaction_pool_get(zero_block.id(), &block_id, &atom2.id).unwrap();
+        assert!(rec.stage().is_new());
+        assert!(rec.pending_stage().unwrap().is_prepared());
+
+        let rec = tx.transaction_pool_get(zero_block.id(), &block_id, &atom3.id).unwrap();
+        assert!(rec.stage().is_prepared());
+        assert!(rec.pending_stage().is_none());
+
+        tx.rollback().unwrap();
+    }
+}
diff --git a/dan_layer/storage/src/consensus_models/block.rs b/dan_layer/storage/src/consensus_models/block.rs
index b097484bd..19e312373 100644
--- a/dan_layer/storage/src/consensus_models/block.rs
+++ b/dan_layer/storage/src/consensus_models/block.rs
@@ -18,6 +18,7 @@ use super::QuorumCertificate;
 use crate::{
     consensus_models::{
         Command,
+        HighQc,
         LastExecuted,
         LastProposed,
         LastVoted,
@@ -25,6 +26,7 @@ use crate::{
         LockedBlock,
         SubstateCreatedProof,
         SubstateUpdate,
+        TransactionRecord,
         Vote,
     },
     Ordering,
@@ -456,6 +458,26 @@ impl<TAddr: NodeAddressable> Block<TAddr> {
         tx.blocks_get_any_with_epoch_range(range, validator_public_key)
     }
 
+    pub fn get_transactions<TTx: StateStoreReadTransaction<Addr = TAddr>>(
+        &self,
+        tx: &mut TTx,
+    ) -> Result<Vec<TransactionRecord>, StorageError> {
+        let tx_ids = self.commands().iter().map(|t| t.transaction_id());
+        let (found, missing) = TransactionRecord::get_any(tx, tx_ids)?;
+        if !missing.is_empty() {
+            return Err(StorageError::NotFound {
+                item: "Transaction".to_string(),
+                key: missing
+                    .into_iter()
+                    .map(|id| id.to_string())
+                    .collect::<Vec<_>>()
+                    .join(", "),
+            });
+        }
+
+        Ok(found)
+    }
+
     pub fn get_substate_updates<TTx: StateStoreReadTransaction<Addr = TAddr>>(
         &self,
         tx: &mut TTx,
@@ -506,7 +528,7 @@ impl<TAddr: NodeAddressable> Block<TAddr> {
         tx: &mut TTx,
         on_lock_block: TFnOnLock,
         on_commit: TFnOnCommit,
-    ) -> Result<(), E>
+    ) -> Result<HighQc, E>
     where
         TTx: StateStoreWriteTransaction<Addr = TAddr> + DerefMut + ?Sized,
         TTx::Target: StateStoreReadTransaction<Addr = TAddr>,
@@ -514,16 +536,16 @@ impl<TAddr: NodeAddressable> Block<TAddr> {
         TFnOnCommit: FnOnce(&mut TTx, &LastExecuted, &Block<TAddr>) -> Result<(), E>,
         E: From<StorageError>,
     {
-        self.justify().update_high_qc(tx)?;
+        let high_qc = self.justify().update_high_qc(tx)?;
 
         // b'' <- b*.justify.node
         let Some(commit_node) = self.justify().get_block(tx.deref_mut()).optional()? else {
-            return Ok(());
+            return Ok(high_qc);
         };
 
         // b' <- b''.justify.node
         let Some(precommit_node) = commit_node.justify().get_block(tx.deref_mut()).optional()? else {
-            return Ok(());
+            return Ok(high_qc);
         };
 
         let locked_block = LockedBlock::get(tx.deref_mut())?;
@@ -563,7 +585,7 @@ impl<TAddr: NodeAddressable> Block<TAddr> {
             );
         }
 
-        Ok(())
+        Ok(high_qc)
     }
 
     /// safeNode predicate (https://arxiv.org/pdf/1803.05069v6.pdf)
@@ -633,6 +655,10 @@ impl BlockId {
     pub fn is_genesis(&self) -> bool {
         self.0.iter().all(|b| *b == 0)
     }
+
+    pub const fn byte_size() -> usize {
+        FixedHash::byte_size()
+    }
 }
 
 impl AsRef<[u8]> for BlockId {
diff --git a/dan_layer/storage/src/consensus_models/command.rs b/dan_layer/storage/src/consensus_models/command.rs
index f68c947e4..855d7d063 100644
--- a/dan_layer/storage/src/consensus_models/command.rs
+++ b/dan_layer/storage/src/consensus_models/command.rs
@@ -30,6 +30,7 @@ impl Evidence {
     }
 
     pub fn all_shards_complete(&self) -> bool {
+        // TODO: we should check that remote has one QC and local has three
         self.evidence.values().all(|qc_ids| !qc_ids.is_empty())
     }
 
@@ -60,6 +61,18 @@ impl Evidence {
     pub fn qc_ids_iter(&self) -> impl Iterator<Item = &QcId> + '_ {
         self.evidence.values().flatten()
     }
+
+    pub fn merge(&mut self, other: Evidence) -> &mut Self {
+        for (shard_id, qc_ids) in other.evidence {
+            let entry = self.evidence.entry(shard_id).or_default();
+            for qc_id in qc_ids {
+                if !entry.contains(&qc_id) {
+                    entry.push(qc_id);
+                }
+            }
+        }
+        self
+    }
 }
 
 impl FromIterator<(ShardId, Vec<QcId>)> for Evidence {
@@ -92,6 +105,16 @@ impl TransactionAtom {
     }
 }
 
+impl Display for TransactionAtom {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "TransactionAtom({}, {}, {}, {})",
+            self.id, self.decision, self.transaction_fee, self.leader_fee
+        )
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
 pub enum Command {
     /// Command to prepare a transaction.
@@ -157,7 +180,7 @@ impl Command {
 
 impl PartialOrd for Command {
     fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-        self.transaction_id().partial_cmp(other.transaction_id())
+        Some(self.cmp(other))
     }
 }
 
diff --git a/dan_layer/storage/src/consensus_models/executed_transaction.rs b/dan_layer/storage/src/consensus_models/executed_transaction.rs
index da63b8489..129a88b24 100644
--- a/dan_layer/storage/src/consensus_models/executed_transaction.rs
+++ b/dan_layer/storage/src/consensus_models/executed_transaction.rs
@@ -94,7 +94,7 @@ impl ExecutedTransaction {
             } else {
                 // TODO: We preserve the original result mainly for debugging purposes, but this is a little hacky
                 ExecuteResult {
-                    finalize: FinalizeResult::reject(
+                    finalize: FinalizeResult::new_rejectted(
                         self.result.finalize.transaction_hash,
                         RejectReason::ShardRejected(format!(
                             "Validators decided to abort: {}",
diff --git a/dan_layer/storage/src/consensus_models/high_qc.rs b/dan_layer/storage/src/consensus_models/high_qc.rs
index b1fe764c1..cc2a48b52 100644
--- a/dan_layer/storage/src/consensus_models/high_qc.rs
+++ b/dan_layer/storage/src/consensus_models/high_qc.rs
@@ -25,7 +25,7 @@ use std::fmt::Display;
 use tari_dan_common_types::NodeHeight;
 
 use crate::{
-    consensus_models::{BlockId, QcId, QuorumCertificate},
+    consensus_models::{Block, BlockId, LeafBlock, QcId, QuorumCertificate},
     StateStoreReadTransaction,
     StateStoreWriteTransaction,
     StorageError,
@@ -50,6 +50,13 @@ impl HighQc {
     pub fn qc_id(&self) -> &QcId {
         &self.qc_id
     }
+
+    pub fn as_leaf_block(&self) -> LeafBlock {
+        LeafBlock {
+            block_id: self.block_id,
+            height: self.block_height,
+        }
+    }
 }
 
 impl HighQc {
@@ -64,6 +71,13 @@ impl HighQc {
         QuorumCertificate::get(tx, &self.qc_id)
     }
 
+    pub fn get_block<TTx: StateStoreReadTransaction + ?Sized>(
+        &self,
+        tx: &mut TTx,
+    ) -> Result<Block<TTx::Addr>, StorageError> {
+        Block::get(tx, &self.block_id)
+    }
+
     pub fn set<TTx: StateStoreWriteTransaction + ?Sized>(&self, tx: &mut TTx) -> Result<(), StorageError> {
         tx.high_qc_set(self)
     }
diff --git a/dan_layer/storage/src/consensus_models/last_proposed.rs b/dan_layer/storage/src/consensus_models/last_proposed.rs
index f3a97f951..90b2097bd 100644
--- a/dan_layer/storage/src/consensus_models/last_proposed.rs
+++ b/dan_layer/storage/src/consensus_models/last_proposed.rs
@@ -35,3 +35,9 @@ impl LastProposed {
         Block::get(tx, &self.block_id)
     }
 }
+
+impl std::fmt::Display for LastProposed {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "(height: {}, block_id: {})", self.height, self.block_id)
+    }
+}
diff --git a/dan_layer/storage/src/consensus_models/leaf_block.rs b/dan_layer/storage/src/consensus_models/leaf_block.rs
index 08470ff79..55857a521 100644
--- a/dan_layer/storage/src/consensus_models/leaf_block.rs
+++ b/dan_layer/storage/src/consensus_models/leaf_block.rs
@@ -31,7 +31,7 @@ use crate::{
     StorageError,
 };
 
-#[derive(Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub struct LeafBlock {
     pub block_id: BlockId,
     pub height: NodeHeight,
diff --git a/dan_layer/storage/src/consensus_models/locked_output.rs b/dan_layer/storage/src/consensus_models/locked_output.rs
index f77d7f43d..f48a8801a 100644
--- a/dan_layer/storage/src/consensus_models/locked_output.rs
+++ b/dan_layer/storage/src/consensus_models/locked_output.rs
@@ -37,6 +37,14 @@ impl LockedOutput {
         tx.locked_outputs_acquire_all(block_id, transaction_id, output_shards)
     }
 
+    pub fn check_locks<TTx>(tx: &mut TTx, output_shards: &[ShardId]) -> Result<SubstateLockState, StorageError>
+    where TTx: StateStoreReadTransaction {
+        if tx.substates_any_exist(output_shards)? {
+            return Ok(SubstateLockState::SomeOutputSubstatesExist);
+        }
+        tx.locked_outputs_check_all(output_shards)
+    }
+
     pub fn try_release_all<TTx, I, B>(tx: &mut TTx, output_shards: I) -> Result<Vec<Self>, StorageError>
     where
         TTx: StateStoreWriteTransaction,
diff --git a/dan_layer/storage/src/consensus_models/mod.rs b/dan_layer/storage/src/consensus_models/mod.rs
index 0653767fb..89f9da35f 100644
--- a/dan_layer/storage/src/consensus_models/mod.rs
+++ b/dan_layer/storage/src/consensus_models/mod.rs
@@ -17,6 +17,7 @@ mod substate;
 mod transaction;
 mod transaction_decision;
 mod transaction_pool;
+mod transaction_pool_status_update;
 mod vote;
 mod vote_signature;
 
@@ -36,5 +37,6 @@ pub use substate::*;
 pub use transaction::*;
 pub use transaction_decision::*;
 pub use transaction_pool::*;
+pub use transaction_pool_status_update::*;
 pub use vote::*;
 pub use vote_signature::*;
diff --git a/dan_layer/storage/src/consensus_models/substate.rs b/dan_layer/storage/src/consensus_models/substate.rs
index dfc161b3b..03fbc1335 100644
--- a/dan_layer/storage/src/consensus_models/substate.rs
+++ b/dan_layer/storage/src/consensus_models/substate.rs
@@ -134,6 +134,14 @@ 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 ShardId>>(
+        tx: &mut TTx,
+        inputs: I,
+        lock_flag: SubstateLockFlag,
+    ) -> Result<SubstateLockState, StorageError> {
+        tx.substates_check_lock_many(inputs, lock_flag)
+    }
+
     pub fn try_unlock_many<'a, TTx: StateStoreWriteTransaction, I: IntoIterator<Item = &'a ShardId>>(
         tx: &mut TTx,
         locked_by_tx: &TransactionId,
diff --git a/dan_layer/storage/src/consensus_models/transaction.rs b/dan_layer/storage/src/consensus_models/transaction.rs
index 6d954024a..ac6929fe8 100644
--- a/dan_layer/storage/src/consensus_models/transaction.rs
+++ b/dan_layer/storage/src/consensus_models/transaction.rs
@@ -60,6 +60,10 @@ impl TransactionRecord {
         }
     }
 
+    pub fn id(&self) -> &TransactionId {
+        self.transaction.id()
+    }
+
     pub fn transaction(&self) -> &Transaction {
         &self.transaction
     }
@@ -108,7 +112,7 @@ impl TransactionRecord {
                 self.result
             } else {
                 Some(ExecuteResult {
-                    finalize: FinalizeResult::reject(
+                    finalize: FinalizeResult::new_rejectted(
                         self.transaction.id().into_array().into(),
                         RejectReason::ShardRejected(format!(
                             "Validators decided to abort: {}",
@@ -141,6 +145,15 @@ impl TransactionRecord {
         Ok(())
     }
 
+    pub fn save_all<'a, TTx, I>(tx: &mut TTx, transactions: I) -> Result<(), StorageError>
+    where
+        TTx: StateStoreWriteTransaction + DerefMut,
+        TTx::Target: StateStoreReadTransaction,
+        I: IntoIterator<Item = &'a TransactionRecord>,
+    {
+        tx.transactions_save_all(transactions)
+    }
+
     pub fn update<TTx: StateStoreWriteTransaction>(&self, tx: &mut TTx) -> Result<(), StorageError> {
         tx.transactions_update(self)
     }
@@ -156,6 +169,19 @@ impl TransactionRecord {
         tx.transactions_exists(tx_id)
     }
 
+    pub fn exists_any<'a, TTx: StateStoreReadTransaction + ?Sized, I: IntoIterator<Item = &'a TransactionId>>(
+        tx: &mut TTx,
+        tx_ids: I,
+    ) -> Result<bool, StorageError> {
+        for tx_id in tx_ids {
+            if tx.transactions_exists(tx_id)? {
+                return Ok(true);
+            }
+        }
+
+        Ok(false)
+    }
+
     pub fn get_any<'a, TTx: StateStoreReadTransaction, I: IntoIterator<Item = &'a TransactionId>>(
         tx: &mut TTx,
         tx_ids: I,
@@ -165,6 +191,7 @@ impl TransactionRecord {
         for rec in &recs {
             tx_ids.remove(rec.transaction.id());
         }
+
         Ok((recs, tx_ids))
     }
 
diff --git a/dan_layer/storage/src/consensus_models/transaction_decision.rs b/dan_layer/storage/src/consensus_models/transaction_decision.rs
index 96cdda163..10d391b92 100644
--- a/dan_layer/storage/src/consensus_models/transaction_decision.rs
+++ b/dan_layer/storage/src/consensus_models/transaction_decision.rs
@@ -25,6 +25,13 @@ impl Decision {
     pub fn is_abort(&self) -> bool {
         matches!(self, Decision::Abort)
     }
+
+    pub fn and(self, other: Self) -> Self {
+        match self {
+            Decision::Commit => other,
+            Decision::Abort => Decision::Abort,
+        }
+    }
 }
 
 impl Display for Decision {
diff --git a/dan_layer/storage/src/consensus_models/transaction_pool.rs b/dan_layer/storage/src/consensus_models/transaction_pool.rs
index ec6aa2ff5..30ac5a71b 100644
--- a/dan_layer/storage/src/consensus_models/transaction_pool.rs
+++ b/dan_layer/storage/src/consensus_models/transaction_pool.rs
@@ -5,7 +5,6 @@ use std::{
     fmt::{Display, Formatter},
     marker::PhantomData,
     num::NonZeroU64,
-    ops::DerefMut,
     str::FromStr,
 };
 
@@ -17,14 +16,14 @@ use tari_dan_common_types::{
 use tari_transaction::TransactionId;
 
 use crate::{
-    consensus_models::{Block, Command, Decision, QcId, TransactionAtom},
+    consensus_models::{Decision, LeafBlock, LockedBlock, QcId, TransactionAtom, TransactionPoolStatusUpdate},
     StateStore,
     StateStoreReadTransaction,
     StateStoreWriteTransaction,
     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)]
 pub enum TransactionPoolStage {
@@ -120,9 +119,20 @@ impl<TStateStore: StateStore> TransactionPool<TStateStore> {
     pub fn get(
         &self,
         tx: &mut TStateStore::ReadTransaction<'_>,
+        leaf: LeafBlock,
         id: &TransactionId,
     ) -> Result<TransactionPoolRecord, TransactionPoolError> {
-        let rec = tx.transaction_pool_get(id)?;
+        // We always want to fetch the state at the current leaf block until the leaf block
+        // let leaf = LeafBlock::get(tx)?;
+        let locked = LockedBlock::get(tx)?;
+        debug!(
+            target: _LOG_TARGET,
+            "TransactionPool::get: transaction_id {}, leaf block {} and locked block {}",
+            id,
+            leaf,
+            locked,
+        );
+        let rec = tx.transaction_pool_get(locked.block_id(), leaf.block_id(), id)?;
         Ok(rec)
     }
 
@@ -131,9 +141,8 @@ impl<TStateStore: StateStore> TransactionPool<TStateStore> {
         tx: &mut TStateStore::ReadTransaction<'_>,
         id: &TransactionId,
     ) -> Result<bool, TransactionPoolError> {
-        // TODO: optimise
-        let rec = tx.transaction_pool_get(id).optional()?;
-        Ok(rec.is_some())
+        let exists = tx.transaction_pool_exists(id)?;
+        Ok(exists)
     }
 
     pub fn insert(
@@ -145,7 +154,7 @@ impl<TStateStore: StateStore> TransactionPool<TStateStore> {
         Ok(())
     }
 
-    pub fn get_batch(
+    pub fn get_batch_for_next_block(
         &self,
         tx: &mut TStateStore::ReadTransaction<'_>,
         max: usize,
@@ -161,26 +170,26 @@ impl<TStateStore: StateStore> TransactionPool<TStateStore> {
         &self,
         tx: &mut TStateStore::ReadTransaction<'_>,
     ) -> Result<bool, TransactionPoolError> {
-        let count = tx.transaction_pool_count(None, None)?;
+        let count = tx.transaction_pool_count(None, Some(true))?;
+        if count > 0 {
+            return Ok(true);
+        }
+        let count = tx.transaction_pool_count(Some(TransactionPoolStage::Prepared), None)?;
+        if count > 0 {
+            return Ok(true);
+        }
+        let count = tx.transaction_pool_count(Some(TransactionPoolStage::LocalPrepared), Some(true))?;
+        if count > 0 {
+            return Ok(true);
+        }
+        let count = tx.transaction_pool_count(Some(TransactionPoolStage::AllPrepared), None)?;
+        if count > 0 {
+            return Ok(true);
+        }
+        let count = tx.transaction_pool_count(Some(TransactionPoolStage::SomePrepared), None)?;
         if count > 0 {
             return Ok(true);
         }
-        // let count = tx.transaction_pool_count(Some(TransactionPoolStage::Prepared), None)?;
-        // if count > 0 {
-        //     return Ok(true);
-        // }
-        // let count = tx.transaction_pool_count(Some(TransactionPoolStage::LocalPrepared), None)?;
-        // if count > 0 {
-        //     return Ok(true);
-        // }
-        // let count = tx.transaction_pool_count(Some(TransactionPoolStage::AllPrepared), None)?;
-        // if count > 0 {
-        //     return Ok(true);
-        // }
-        // let count = tx.transaction_pool_count(Some(TransactionPoolStage::SomePrepared), None)?;
-        // if count > 0 {
-        //     return Ok(true);
-        // }
         Ok(count > 0)
     }
 
@@ -192,53 +201,11 @@ impl<TStateStore: StateStore> TransactionPool<TStateStore> {
     pub fn confirm_all_transitions<'a, I: IntoIterator<Item = &'a TransactionId>>(
         &self,
         tx: &mut TStateStore::WriteTransaction<'_>,
+        locked_block: &LockedBlock,
+        new_locked_block: &LockedBlock,
         tx_ids: I,
     ) -> Result<(), TransactionPoolError> {
-        tx.transaction_pool_set_all_transitions(tx_ids)?;
-        Ok(())
-    }
-
-    pub fn rollback_pending_stages(
-        &self,
-        tx: &mut TStateStore::WriteTransaction<'_>,
-        block: &Block<TStateStore::Addr>,
-    ) -> Result<(), TransactionPoolError> {
-        for cmd in block.commands() {
-            let transaction = self.get(tx.deref_mut(), cmd.transaction_id())?;
-
-            debug!(
-                target: LOG_TARGET,
-                "↩️ Rolling back pending stage for transaction {} from {:?} ",
-                cmd.transaction_id(),
-                transaction.pending_stage,
-            );
-            match cmd {
-                Command::Prepare(t) => {
-                    tx.transaction_pool_update(t.id(), None, Some(None), None, None, Some(true))?;
-                },
-                Command::LocalPrepared(t) => {
-                    // TODO: We can never go back from <LocalPrepared, true> to Prepared
-                    tx.transaction_pool_update(
-                        t.id(),
-                        None,
-                        Some(Some(TransactionPoolStage::Prepared)),
-                        None,
-                        None,
-                        Some(true),
-                    )?;
-                },
-                Command::Accept(t) => {
-                    tx.transaction_pool_update(
-                        t.id(),
-                        None,
-                        Some(Some(TransactionPoolStage::LocalPrepared)),
-                        None,
-                        None,
-                        Some(true),
-                    )?;
-                },
-            }
-        }
+        tx.transaction_pool_set_all_transitions(locked_block, new_locked_block, tx_ids)?;
         Ok(())
     }
 }
@@ -274,6 +241,8 @@ impl TransactionPoolRecord {
 
     pub fn current_decision(&self) -> Decision {
         self.remote_decision()
+            // Prioritize remote ABORT
+            .filter(|d| d.is_abort())
             .or_else(|| self.local_decision())
             .unwrap_or(self.original_decision())
     }
@@ -357,7 +326,14 @@ impl TransactionPoolRecord {
     }
 
     pub fn set_remote_decision(&mut self, decision: Decision) -> &mut Self {
-        self.remote_decision = Some(decision);
+        // 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
     }
 
@@ -365,12 +341,24 @@ impl TransactionPoolRecord {
         self.local_decision = Some(decision);
         self
     }
+
+    pub fn add_evidence(&mut self, committee_shard: &CommitteeShard, qc_id: QcId) -> &mut Self {
+        let evidence = &mut self.transaction.evidence;
+        for (shard, qcs_mut) in evidence.iter_mut() {
+            if committee_shard.includes_shard(shard) {
+                qcs_mut.push(qc_id);
+            }
+        }
+
+        self
+    }
 }
 
 impl TransactionPoolRecord {
-    pub fn pending_transition<TTx: StateStoreWriteTransaction>(
+    pub fn add_pending_status_update<TTx: StateStoreWriteTransaction>(
         &mut self,
         tx: &mut TTx,
+        block: LeafBlock,
         pending_stage: TransactionPoolStage,
         is_ready: bool,
     ) -> Result<(), TransactionPoolError> {
@@ -384,33 +372,44 @@ impl TransactionPoolRecord {
             ((TransactionPoolStage::AllPrepared, TransactionPoolStage::SomePrepared), false) => {},
             _ => {
                 return Err(TransactionPoolError::InvalidTransactionTransition {
-                    from: self.stage,
+                    from: self.current_stage(),
                     to: pending_stage,
                     is_ready,
                 })
             },
         }
 
-        tx.transaction_pool_update(
-            &self.transaction.id,
-            None,
-            Some(Some(pending_stage)),
-            None,
-            None,
-            Some(is_ready),
-        )?;
+        let update = TransactionPoolStatusUpdate {
+            block_id: block.block_id,
+            block_height: block.height,
+            transaction_id: self.transaction.id,
+            stage: pending_stage,
+            evidence: self.transaction.evidence.clone(),
+            is_ready,
+            local_decision: self.current_local_decision(),
+        };
+
+        tx.transaction_pool_add_pending_update(update)?;
         self.pending_stage = Some(pending_stage);
 
         Ok(())
     }
 
-    pub fn update_remote_decision<TTx: StateStoreWriteTransaction>(
+    pub fn update_remote_data<TTx: StateStoreWriteTransaction>(
         &mut self,
         tx: &mut TTx,
         decision: Decision,
+        foreign_qc_id: QcId,
+        foreign_committee_shard: &CommitteeShard,
     ) -> Result<(), TransactionPoolError> {
-        tx.transaction_pool_update(&self.transaction.id, None, None, None, Some(decision), None)?;
+        self.add_evidence(foreign_committee_shard, foreign_qc_id);
         self.set_remote_decision(decision);
+        tx.transaction_pool_update(
+            &self.transaction.id,
+            None,
+            Some(decision),
+            Some(&self.transaction.evidence),
+        )?;
         Ok(())
     }
 
@@ -421,41 +420,24 @@ impl TransactionPoolRecord {
     ) -> Result<(), TransactionPoolError> {
         if self.local_decision.map(|d| d != decision).unwrap_or(true) {
             self.set_local_decision(decision);
-            tx.transaction_pool_update(&self.transaction.id, None, None, Some(decision), None, None)?;
+            tx.transaction_pool_update(&self.transaction.id, Some(decision), None, None)?;
         }
         Ok(())
     }
 
-    pub fn update_evidence<TTx: StateStoreWriteTransaction>(
-        &mut self,
-        tx: &mut TTx,
-        committee_shard: &CommitteeShard,
-        qc_id: QcId,
-    ) -> Result<(), TransactionPoolError> {
-        let evidence = &mut self.transaction.evidence;
-        for (shard, qcs_mut) in evidence.iter_mut() {
-            if committee_shard.includes_shard(shard) {
-                qcs_mut.push(qc_id);
-            }
-        }
-        tx.transaction_pool_update(&self.transaction.id, Some(evidence), None, None, None, None)?;
-
-        Ok(())
-    }
-
     pub fn remove<TTx: StateStoreWriteTransaction>(&self, tx: &mut TTx) -> Result<(), TransactionPoolError> {
         tx.transaction_pool_remove(&self.transaction.id)?;
         Ok(())
     }
 
-    pub fn remove_any<TTx, I>(tx: &mut TTx, transaction_ids: I) -> Result<(), TransactionPoolError>
+    pub fn remove_any<'a, TTx, I>(tx: &mut TTx, transaction_ids: I) -> Result<(), TransactionPoolError>
     where
         TTx: StateStoreWriteTransaction,
-        I: IntoIterator<Item = TransactionId>,
+        I: IntoIterator<Item = &'a TransactionId>,
     {
         // TODO(perf): n queries
         for id in transaction_ids {
-            let _ = tx.transaction_pool_remove(&id).optional()?;
+            let _ = tx.transaction_pool_remove(id).optional()?;
         }
         Ok(())
     }
diff --git a/dan_layer/storage/src/consensus_models/transaction_pool_status_update.rs b/dan_layer/storage/src/consensus_models/transaction_pool_status_update.rs
new file mode 100644
index 000000000..acc1c6963
--- /dev/null
+++ b/dan_layer/storage/src/consensus_models/transaction_pool_status_update.rs
@@ -0,0 +1,48 @@
+//   Copyright 2023 The Tari Project
+//   SPDX-License-Identifier: BSD-3-Clause
+
+use tari_dan_common_types::NodeHeight;
+use tari_transaction::TransactionId;
+
+use crate::consensus_models::{BlockId, Decision, Evidence, TransactionPoolStage};
+
+#[derive(Debug, Clone)]
+pub struct TransactionPoolStatusUpdate {
+    pub block_id: BlockId,
+    pub block_height: NodeHeight,
+    pub transaction_id: TransactionId,
+    pub stage: TransactionPoolStage,
+    pub evidence: Evidence,
+    pub is_ready: bool,
+    pub local_decision: Decision,
+}
+
+impl TransactionPoolStatusUpdate {
+    pub fn block_id(&self) -> &BlockId {
+        &self.block_id
+    }
+
+    pub fn block_height(&self) -> NodeHeight {
+        self.block_height
+    }
+
+    pub fn transaction_id(&self) -> &TransactionId {
+        &self.transaction_id
+    }
+
+    pub fn stage(&self) -> TransactionPoolStage {
+        self.stage
+    }
+
+    pub fn evidence(&self) -> &Evidence {
+        &self.evidence
+    }
+
+    pub fn is_ready(&self) -> bool {
+        self.is_ready
+    }
+
+    pub fn local_decision(&self) -> Decision {
+        self.local_decision
+    }
+}
diff --git a/dan_layer/storage/src/state_store/mod.rs b/dan_layer/storage/src/state_store/mod.rs
index 3045a33f5..f4d1e154b 100644
--- a/dan_layer/storage/src/state_store/mod.rs
+++ b/dan_layer/storage/src/state_store/mod.rs
@@ -33,6 +33,7 @@ use crate::{
         TransactionAtom,
         TransactionPoolRecord,
         TransactionPoolStage,
+        TransactionPoolStatusUpdate,
         TransactionRecord,
         Vote,
     },
@@ -89,6 +90,7 @@ pub trait StateStoreReadTransaction {
     fn high_qc_get(&mut self) -> Result<HighQc, 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,
@@ -140,7 +142,13 @@ pub trait StateStoreReadTransaction {
     ) -> Result<QuorumCertificate<Self::Addr>, StorageError>;
 
     // -------------------------------- Transaction Pools -------------------------------- //
-    fn transaction_pool_get(&mut self, transaction_id: &TransactionId) -> Result<TransactionPoolRecord, StorageError>;
+    fn transaction_pool_get(
+        &mut self,
+        from_block_id: &BlockId,
+        to_block_id: &BlockId,
+        transaction_id: &TransactionId,
+    ) -> Result<TransactionPoolRecord, StorageError>;
+    fn transaction_pool_exists(&mut self, transaction_id: &TransactionId) -> Result<bool, StorageError>;
     fn transaction_pool_get_many_ready(&mut self, max_txs: usize) -> Result<Vec<TransactionPoolRecord>, StorageError>;
     fn transaction_pool_count(
         &mut self,
@@ -189,6 +197,16 @@ pub trait StateStoreReadTransaction {
         &mut self,
         transaction_id: &TransactionId,
     ) -> Result<Vec<SubstateRecord>, StorageError>;
+    fn substates_check_lock_many<'a, I: IntoIterator<Item = &'a ShardId>>(
+        &mut self,
+        objects: I,
+        lock_flag: SubstateLockFlag,
+    ) -> Result<SubstateLockState, StorageError>;
+
+    fn locked_outputs_check_all<I, B>(&mut self, output_shards: I) -> Result<SubstateLockState, StorageError>
+    where
+        I: IntoIterator<Item = B>,
+        B: Borrow<ShardId>;
 }
 
 pub trait StateStoreWriteTransaction {
@@ -223,6 +241,10 @@ pub trait StateStoreWriteTransaction {
     // -------------------------------- Transaction -------------------------------- //
     fn transactions_insert(&mut self, transaction: &Transaction) -> Result<(), StorageError>;
     fn transactions_update(&mut self, transaction: &TransactionRecord) -> Result<(), StorageError>;
+    fn transactions_save_all<'a, I: IntoIterator<Item = &'a TransactionRecord>>(
+        &mut self,
+        transaction: I,
+    ) -> Result<(), StorageError>;
     // -------------------------------- Transaction Pool -------------------------------- //
     fn transaction_pool_insert(
         &mut self,
@@ -230,18 +252,23 @@ pub trait StateStoreWriteTransaction {
         stage: TransactionPoolStage,
         is_ready: bool,
     ) -> Result<(), StorageError>;
+    fn transaction_pool_add_pending_update(
+        &mut self,
+        pool_update: TransactionPoolStatusUpdate,
+    ) -> Result<(), StorageError>;
+
     fn transaction_pool_update(
         &mut self,
         transaction_id: &TransactionId,
-        evidence: Option<&Evidence>,
-        pending_stage: Option<Option<TransactionPoolStage>>,
         local_decision: Option<Decision>,
         remote_decision: Option<Decision>,
-        is_ready: Option<bool>,
+        remote_evidence: Option<&Evidence>,
     ) -> Result<(), StorageError>;
     fn transaction_pool_remove(&mut self, transaction_id: &TransactionId) -> Result<(), StorageError>;
     fn transaction_pool_set_all_transitions<'a, I: IntoIterator<Item = &'a TransactionId>>(
         &mut self,
+        locked_block: &LockedBlock,
+        new_locked_block: &LockedBlock,
         tx_ids: I,
     ) -> Result<(), StorageError>;
 
diff --git a/dan_layer/transaction/src/transaction_id.rs b/dan_layer/transaction/src/transaction_id.rs
index 8214dd1da..b3d25d5e6 100644
--- a/dan_layer/transaction/src/transaction_id.rs
+++ b/dan_layer/transaction/src/transaction_id.rs
@@ -36,6 +36,10 @@ impl TransactionId {
         let bytes = from_hex(hex).map_err(|_| FixedHashSizeError)?;
         Self::try_from(bytes.as_slice())
     }
+
+    pub const fn byte_size() -> usize {
+        32
+    }
 }
 
 impl AsRef<[u8]> for TransactionId {
diff --git a/dan_layer/validator_node_rpc/proto/rpc.proto b/dan_layer/validator_node_rpc/proto/rpc.proto
index cbc47c27a..2cefae975 100644
--- a/dan_layer/validator_node_rpc/proto/rpc.proto
+++ b/dan_layer/validator_node_rpc/proto/rpc.proto
@@ -193,9 +193,21 @@ message SyncBlocksRequest {
 }
 
 message SyncBlocksResponse {
-  tari.dan.consensus.Block block = 1;
-  repeated tari.dan.consensus.QuorumCertificate quorum_certificates = 2;
-  repeated SubstateUpdate substate_updates = 3;
+  oneof sync_data {
+    tari.dan.consensus.Block block = 1;
+    QuorumCertificates quorum_certificates = 2;
+    uint32 substate_count = 3;
+    SubstateUpdate substate_update = 4;
+    Transactions transactions = 5;
+  }
+}
+
+message QuorumCertificates {
+  repeated tari.dan.consensus.QuorumCertificate quorum_certificates = 1;
+}
+
+message Transactions {
+  repeated tari.dan.transaction.Transaction transactions = 1;
 }
 
 message GetHighQcRequest { }
diff --git a/dan_layer/validator_node_rpc/src/block_sync.rs b/dan_layer/validator_node_rpc/src/block_sync.rs
new file mode 100644
index 000000000..2a5f2109e
--- /dev/null
+++ b/dan_layer/validator_node_rpc/src/block_sync.rs
@@ -0,0 +1,48 @@
+//   Copyright 2023 The Tari Project
+//   SPDX-License-Identifier: BSD-3-Clause
+
+use crate::{
+    proto,
+    proto::{
+        consensus::{Block, QuorumCertificate},
+        rpc::{sync_blocks_response::SyncData, QuorumCertificates, SubstateUpdate, Transactions},
+        transaction::Transaction,
+    },
+};
+
+impl proto::rpc::SyncBlocksResponse {
+    pub fn into_block(self) -> Option<Block> {
+        match self.sync_data {
+            Some(SyncData::Block(block)) => Some(block),
+            _ => None,
+        }
+    }
+
+    pub fn into_quorum_certificates(self) -> Option<Vec<QuorumCertificate>> {
+        match self.sync_data {
+            Some(SyncData::QuorumCertificates(QuorumCertificates { quorum_certificates })) => Some(quorum_certificates),
+            _ => None,
+        }
+    }
+
+    pub fn substate_count(&self) -> Option<u32> {
+        match self.sync_data {
+            Some(SyncData::SubstateCount(count)) => Some(count),
+            _ => None,
+        }
+    }
+
+    pub fn into_substate_update(self) -> Option<SubstateUpdate> {
+        match self.sync_data {
+            Some(SyncData::SubstateUpdate(update)) => Some(update),
+            _ => None,
+        }
+    }
+
+    pub fn into_transactions(self) -> Option<Vec<Transaction>> {
+        match self.sync_data {
+            Some(SyncData::Transactions(Transactions { transactions })) => Some(transactions),
+            _ => None,
+        }
+    }
+}
diff --git a/dan_layer/validator_node_rpc/src/lib.rs b/dan_layer/validator_node_rpc/src/lib.rs
index 0d226bda0..ca6204cba 100644
--- a/dan_layer/validator_node_rpc/src/lib.rs
+++ b/dan_layer/validator_node_rpc/src/lib.rs
@@ -20,6 +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.
 
+mod block_sync;
 pub mod client;
 mod conversions;
 mod error;
@@ -27,4 +28,5 @@ pub mod peer_sync;
 pub mod proto;
 pub mod rpc_service;
 mod utils;
+
 pub use error::ValidatorNodeRpcClientError;