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;