From 2acb91dc9acec7b758aa003c78ffe9f2dca0892c Mon Sep 17 00:00:00 2001
From: Stan Bondi <sdbondi@users.noreply.github.com>
Date: Wed, 21 Aug 2024 10:03:17 +0400
Subject: [PATCH] feat(consensus): sequence transaction from foreign
 LocalPrepare/Accept

---
 Cargo.lock                                    |  17 +
 .../src/transaction_executor.rs               |  10 -
 .../tari_indexer/src/json_rpc/handlers.rs     |   4 +-
 applications/tari_swarm_daemon/Cargo.toml     |   1 +
 applications/tari_swarm_daemon/src/cli.rs     |   2 +
 applications/tari_swarm_daemon/src/config.rs  |   7 +-
 applications/tari_swarm_daemon/src/main.rs    |   6 +-
 .../src/process_manager/instances/manager.rs  |   8 +-
 .../src/process_manager/manager.rs            |  42 ++-
 .../src/webserver/rpc/validator_nodes.rs      |   2 +
 .../webui/src/routes/Main.tsx                 |  39 ++-
 .../webui/src/utils/json_rpc.tsx              |   4 +-
 .../tari_validator_node/src/bootstrap.rs      |   3 +-
 .../consensus/block_transaction_executor.rs   |  27 --
 .../src/json_rpc/handlers.rs                  |   6 +-
 .../src/p2p/services/mempool/gossip.rs        |   6 +-
 .../src/p2p/services/mempool/service.rs       |  11 +-
 .../src/p2p/services/messaging/outbound.rs    |   2 +-
 dan_layer/common_types/src/committee.rs       |  10 +-
 dan_layer/consensus/src/hotstuff/common.rs    |  26 +-
 dan_layer/consensus/src/hotstuff/error.rs     |   5 +
 .../src/hotstuff/on_message_validate.rs       | 148 +++++++--
 .../consensus/src/hotstuff/on_propose.rs      |  95 ++++--
 .../on_ready_to_vote_on_local_block.rs        | 298 +++++++++---------
 .../hotstuff/on_receive_foreign_proposal.rs   | 222 ++++++++-----
 .../src/hotstuff/on_receive_local_proposal.rs |  43 +--
 .../hotstuff/on_receive_new_transaction.rs    |   4 +-
 .../src/hotstuff/substate_store/error.rs      |   6 +-
 .../hotstuff/substate_store/pending_store.rs  |  35 +-
 .../hotstuff/transaction_manager/manager.rs   |  55 ++--
 .../hotstuff/transaction_manager/prepared.rs  |   6 +-
 dan_layer/consensus/src/hotstuff/worker.rs    |  79 +++--
 dan_layer/consensus/src/messages/proposal.rs  |  18 +-
 dan_layer/consensus_tests/src/consensus.rs    |  40 ++-
 .../consensus_tests/src/substate_store.rs     |   4 +-
 .../src/support/epoch_manager.rs              |  14 +-
 .../src/support/executions_store.rs           |  10 +-
 .../consensus_tests/src/support/harness.rs    |  39 ++-
 .../src/support/transaction.rs                |  63 ++--
 dan_layer/engine_types/src/substate.rs        |  16 +
 .../base_layer/base_layer_epoch_manager.rs    |   3 +-
 .../epoch_manager/src/base_layer/handle.rs    |   3 +-
 .../epoch_manager/src/base_layer/types.rs     |   3 +-
 dan_layer/epoch_manager/src/traits.rs         |   3 +-
 dan_layer/rpc_state_sync/src/manager.rs       | 174 +++++-----
 .../up.sql                                    |  47 ++-
 dan_layer/state_store_sqlite/src/reader.rs    |   1 +
 dan_layer/state_store_sqlite/src/schema.rs    |  24 ++
 .../src/sql_models/foreign_parked_block.rs    |  34 ++
 .../state_store_sqlite/src/sql_models/mod.rs  |   2 +
 .../src/sql_models/transaction_pool.rs        |  12 +-
 dan_layer/state_store_sqlite/src/writer.rs    | 232 ++++++++++----
 .../storage/src/consensus_models/block.rs     |  22 +-
 .../src/consensus_models/block_pledges.rs     |  10 +-
 .../storage/src/consensus_models/command.rs   | 236 ++------------
 .../storage/src/consensus_models/evidence.rs  | 253 +++++++++++++++
 .../foreign_parked_proposal.rs                |  77 +++++
 dan_layer/storage/src/consensus_models/mod.rs |   4 +
 .../storage/src/consensus_models/substate.rs  |   2 +-
 .../src/consensus_models/transaction.rs       |  20 +-
 .../src/consensus_models/transaction_pool.rs  |  77 +++--
 .../transaction_pool_status_update.rs         |   4 +
 .../storage/src/global/backend_adapter.rs     |   3 +-
 .../storage/src/global/validator_node_db.rs   |   4 +-
 dan_layer/storage/src/state_store/mod.rs      |  22 +-
 .../src/global/backend_adapter.rs             |  79 ++---
 .../src/global/models/committee.rs            |  18 +-
 .../storage_sqlite/src/global/models/mod.rs   |   4 +
 dan_layer/storage_sqlite/tests/global_db.rs   |   4 +-
 dan_layer/transaction/src/transaction.rs      |  17 +-
 dan_layer/transaction/src/transaction_id.rs   |   7 +
 71 files changed, 1802 insertions(+), 1032 deletions(-)
 create mode 100644 dan_layer/state_store_sqlite/src/sql_models/foreign_parked_block.rs
 create mode 100644 dan_layer/storage/src/consensus_models/evidence.rs
 create mode 100644 dan_layer/storage/src/consensus_models/foreign_parked_proposal.rs

diff --git a/Cargo.lock b/Cargo.lock
index 590bb748ce..9efa12da88 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2328,6 +2328,12 @@ version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3c877555693c14d2f84191cfd3ad8582790fc52b5e2274b40b59cf5f5cea25c7"
 
+[[package]]
+name = "deunicode"
+version = "1.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "339544cc9e2c4dc3fc7149fd630c5f22263a4fdf18a98afd0075784968b5cf00"
+
 [[package]]
 name = "dialoguer"
 version = "0.10.4"
@@ -8197,6 +8203,16 @@ dependencies = [
  "autocfg",
 ]
 
+[[package]]
+name = "slug"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "882a80f72ee45de3cc9a5afeb2da0331d58df69e4e7d8eeb5d3c7784ae67e724"
+dependencies = [
+ "deunicode",
+ "wasm-bindgen",
+]
+
 [[package]]
 name = "sluice"
 version = "0.5.5"
@@ -9849,6 +9865,7 @@ dependencies = [
  "reqwest",
  "serde",
  "serde_json",
+ "slug",
  "tari_common",
  "tari_common_types",
  "tari_core",
diff --git a/applications/tari_dan_app_utilities/src/transaction_executor.rs b/applications/tari_dan_app_utilities/src/transaction_executor.rs
index e8793f97b2..2ee288b18d 100644
--- a/applications/tari_dan_app_utilities/src/transaction_executor.rs
+++ b/applications/tari_dan_app_utilities/src/transaction_executor.rs
@@ -130,16 +130,6 @@ where TTemplateProvider: TemplateProvider<Template = LoadedTemplate>
             self.network,
         );
         let result = processor.execute(transaction.clone())?;
-        //     Ok(result) => result,
-        //     // TODO: This may occur due to an internal error (e.g. OOM, etc).
-        //     Err(err) => ExecuteResult {
-        //         finalize: FinalizeResult::new_rejected(
-        //             tx_id,
-        //             RejectReason::ExecutionFailure(format!("BUG: {err}")),
-        //         ),
-        //         execution_time: Duration::default(),
-        //     },
-        // };
 
         Ok(ExecutionOutput { transaction, result })
     }
diff --git a/applications/tari_indexer/src/json_rpc/handlers.rs b/applications/tari_indexer/src/json_rpc/handlers.rs
index 4921e94e03..2a875e588e 100644
--- a/applications/tari_indexer/src/json_rpc/handlers.rs
+++ b/applications/tari_indexer/src/json_rpc/handlers.rs
@@ -29,7 +29,7 @@ use axum_jrpc::{
     JsonRpcResponse,
 };
 use libp2p::swarm::dial_opts::{DialOpts, PeerCondition};
-use log::warn;
+use log::{info, warn};
 use serde_json::{self as json, json, Value};
 use tari_base_node_client::{grpc::GrpcBaseNodeClient, types::BaseLayerConsensusConstants, BaseNodeClient};
 use tari_crypto::tari_utilities::hex::to_hex;
@@ -535,6 +535,8 @@ impl JsonRpcHandlers {
                 e => Self::internal_error(answer_id, e),
             })?;
 
+        info!(target: LOG_TARGET, "✅ Transaction submitted: {}", transaction_id);
+
         Ok(JsonRpcResponse::success(answer_id, SubmitTransactionResponse {
             result: IndexerTransactionFinalizedResult::Pending,
             transaction_id,
diff --git a/applications/tari_swarm_daemon/Cargo.toml b/applications/tari_swarm_daemon/Cargo.toml
index 7712b35ead..d45b7f10d4 100644
--- a/applications/tari_swarm_daemon/Cargo.toml
+++ b/applications/tari_swarm_daemon/Cargo.toml
@@ -31,6 +31,7 @@ humantime = { workspace = true }
 include_dir = { workspace = true }
 json5 = { workspace = true }
 lockfile = "0.4.0"
+slug = "0.1.6"
 log = { workspace = true }
 mime_guess = { workspace = true }
 reqwest = { workspace = true, features = ["json"] }
diff --git a/applications/tari_swarm_daemon/src/cli.rs b/applications/tari_swarm_daemon/src/cli.rs
index ae44d2c01a..536c728c67 100644
--- a/applications/tari_swarm_daemon/src/cli.rs
+++ b/applications/tari_swarm_daemon/src/cli.rs
@@ -69,6 +69,8 @@ pub struct Overrides {
     pub binaries_root: Option<PathBuf>,
     #[clap(long)]
     pub start_port: Option<u16>,
+    #[clap(short = 'k', long)]
+    pub skip_registration: bool,
 }
 
 impl Overrides {
diff --git a/applications/tari_swarm_daemon/src/config.rs b/applications/tari_swarm_daemon/src/config.rs
index 564a7ea6f2..cc949544f3 100644
--- a/applications/tari_swarm_daemon/src/config.rs
+++ b/applications/tari_swarm_daemon/src/config.rs
@@ -16,7 +16,7 @@ use tokio::{
     io::{AsyncReadExt, AsyncWriteExt},
 };
 
-use crate::cli::Cli;
+use crate::cli::{Cli, Commands};
 
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct Config {
@@ -26,6 +26,8 @@ pub struct Config {
     pub webserver: WebserverConfig,
     #[serde(flatten)]
     pub processes: ProcessesConfig,
+    #[serde(default)]
+    pub skip_registration: bool,
 }
 
 impl Config {
@@ -54,6 +56,9 @@ impl Config {
     }
 
     fn overrides_from_cli(&mut self, cli: &Cli) {
+        if let Commands::Start(ref overrides) = cli.command {
+            self.skip_registration = overrides.skip_registration;
+        }
         if let Some(ref base_dir) = cli.common.base_dir {
             self.base_dir.clone_from(base_dir);
         }
diff --git a/applications/tari_swarm_daemon/src/main.rs b/applications/tari_swarm_daemon/src/main.rs
index 73d90a389b..cac087a282 100644
--- a/applications/tari_swarm_daemon/src/main.rs
+++ b/applications/tari_swarm_daemon/src/main.rs
@@ -172,9 +172,10 @@ fn get_base_config(cli: &Cli) -> anyhow::Result<Config> {
                 .ok()
                 .and_then(|p| p.parent().map(|p| p.to_path_buf()))
         })
-        .unwrap_or_else(|| std::env::current_dir().unwrap());
+        .unwrap_or_else(|| std::env::current_dir().unwrap().join("data").join("swarm"));
 
     Ok(Config {
+        skip_registration: false,
         network: cli.common.network.unwrap_or(Network::LocalNet),
         start_port: 12000,
         base_dir: base_dir
@@ -204,7 +205,7 @@ async fn start(cli: &Cli) -> anyhow::Result<()> {
 
     create_paths(&config).await?;
 
-    let shutdown = Shutdown::new();
+    let mut shutdown = Shutdown::new();
     let signal = shutdown.to_signal().select(exit_signal()?);
     let (task_handle, pm_handle) = process_manager::spawn(&config, shutdown.to_signal());
     let webserver = webserver::spawn(config, shutdown.to_signal(), pm_handle.clone());
@@ -212,6 +213,7 @@ async fn start(cli: &Cli) -> anyhow::Result<()> {
     tokio::select! {
         _ = signal => {
             log::info!("Terminating all instances...");
+            shutdown.trigger();
             let num_instances = pm_handle.stop_all().await?;
             log::info!("Terminated {num_instances} instances");
         },
diff --git a/applications/tari_swarm_daemon/src/process_manager/instances/manager.rs b/applications/tari_swarm_daemon/src/process_manager/instances/manager.rs
index 78cde9cf9d..5e94bfdae2 100644
--- a/applications/tari_swarm_daemon/src/process_manager/instances/manager.rs
+++ b/applications/tari_swarm_daemon/src/process_manager/instances/manager.rs
@@ -11,6 +11,7 @@ use std::{
 
 use anyhow::{anyhow, Context};
 use log::info;
+use slug::slugify;
 use tari_common::configuration::Network;
 use tokio::{
     fs,
@@ -83,7 +84,7 @@ impl InstanceManager {
                 self.fork_new(
                     executable,
                     instance.instance_type,
-                    format!("{}-#{}", instance.name, i),
+                    format!("{}-#{:02}", instance.name, i),
                     instance.settings.clone(),
                 )
                 .await?;
@@ -131,10 +132,7 @@ impl InstanceManager {
 
         let mut allocated_ports = ports.unwrap_or_else(|| self.port_allocator.create());
 
-        let base_path = self
-            .base_path
-            .join("processes")
-            .join(format!("{instance_id}-{instance_type}"));
+        let base_path = self.base_path.join("processes").join(slugify(&instance_name));
         fs::create_dir_all(&base_path).await?;
 
         let context = ProcessContext::new(
diff --git a/applications/tari_swarm_daemon/src/process_manager/manager.rs b/applications/tari_swarm_daemon/src/process_manager/manager.rs
index f81463bbde..ccdbba5185 100644
--- a/applications/tari_swarm_daemon/src/process_manager/manager.rs
+++ b/applications/tari_swarm_daemon/src/process_manager/manager.rs
@@ -27,12 +27,14 @@ pub struct ProcessManager {
     instance_manager: InstanceManager,
     rx_request: mpsc::Receiver<ProcessManagerRequest>,
     shutdown_signal: ShutdownSignal,
+    skip_registration: bool,
 }
 
 impl ProcessManager {
     pub fn new(config: &Config, shutdown_signal: ShutdownSignal) -> (Self, ProcessManagerHandle) {
         let (tx_request, rx_request) = mpsc::channel(1);
         let this = Self {
+            skip_registration: config.skip_registration,
             executable_manager: ExecutableManager::new(
                 config.processes.executables.clone(),
                 config.processes.force_compile,
@@ -49,21 +51,39 @@ impl ProcessManager {
         (this, ProcessManagerHandle::new(tx_request))
     }
 
-    pub async fn start(mut self) -> anyhow::Result<()> {
+    async fn setup(&mut self) -> anyhow::Result<()> {
         info!("Starting process manager");
         let executables = self.executable_manager.prepare_all().await?;
         self.instance_manager.fork_all(executables).await?;
 
-        let num_vns = self.instance_manager.num_validator_nodes();
-        // Mine some initial funds, guessing 10 blocks to allow for coinbase maturity
-        self.mine(num_vns + 10).await.context("mining failed")?;
-        self.wait_for_wallet_funds(num_vns)
-            .await
-            .context("waiting for wallet funds")?;
+        if !self.skip_registration {
+            let num_vns = self.instance_manager.num_validator_nodes();
+            // Mine some initial funds, guessing 10 blocks to allow for coinbase maturity
+            self.mine(num_vns + 10).await.context("mining failed")?;
+            self.wait_for_wallet_funds(num_vns)
+                .await
+                .context("waiting for wallet funds")?;
+
+            self.register_all_validator_nodes()
+                .await
+                .context("registering validator node via GRPC")?;
+        }
+
+        Ok(())
+    }
 
-        self.register_all_validator_nodes()
-            .await
-            .context("registering validator node via GRPC")?;
+    pub async fn start(mut self) -> anyhow::Result<()> {
+        let mut shutdown_signal = self.shutdown_signal.clone();
+
+        tokio::select! {
+            result = self.setup() => {
+                 result?;
+            },
+            _ = shutdown_signal.wait() => {
+                info!("Shutting down process manager");
+                return Ok(());
+            }
+        }
 
         loop {
             tokio::select! {
@@ -228,7 +248,7 @@ impl ProcessManager {
             // inputs for a transaction.
             sleep(Duration::from_secs(2)).await;
         }
-        self.mine(10).await?;
+        self.mine(20).await?;
         Ok(())
     }
 
diff --git a/applications/tari_swarm_daemon/src/webserver/rpc/validator_nodes.rs b/applications/tari_swarm_daemon/src/webserver/rpc/validator_nodes.rs
index d3e9ef8007..e20904a70b 100644
--- a/applications/tari_swarm_daemon/src/webserver/rpc/validator_nodes.rs
+++ b/applications/tari_swarm_daemon/src/webserver/rpc/validator_nodes.rs
@@ -18,6 +18,7 @@ pub struct ListValidatorNodesResponse {
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct ValidatorNodeInfo {
+    pub instance_id: InstanceId,
     pub name: String,
     pub web: String,
     pub jrpc: String,
@@ -42,6 +43,7 @@ pub async fn list(
             let jrpc = format!("http://localhost:{json_rpc_port}");
 
             Ok(ValidatorNodeInfo {
+                instance_id: instance.id,
                 name: instance.name,
                 web,
                 jrpc,
diff --git a/applications/tari_swarm_daemon/webui/src/routes/Main.tsx b/applications/tari_swarm_daemon/webui/src/routes/Main.tsx
index c759a6cd08..502b03a66b 100644
--- a/applications/tari_swarm_daemon/webui/src/routes/Main.tsx
+++ b/applications/tari_swarm_daemon/webui/src/routes/Main.tsx
@@ -37,16 +37,15 @@ async function jsonRpc2(address: string, method: string, params: any = null) {
   return json.result;
 }
 
-function ExtraInfoVN({ name, url, setRow, addTxToPool, autoRefresh, state, horizontal }: {
+function ExtraInfoVN({ name, url, addTxToPool, autoRefresh, state, horizontal }: {
   name: string,
   url: string,
-  setRow: any,
   addTxToPool: any,
   autoRefresh: boolean,
   state: any,
   horizontal: boolean
 }) {
-  const [bucket, setBucket] = useState(null);
+  const [committeeInfo, setCommitteeInfo] = useState<any>(null);
   const [epoch, setEpoch] = useState(null);
   const [height, setHeight] = useState(null);
   const [pool, setPool] = useState([]);
@@ -65,8 +64,8 @@ function ExtraInfoVN({ name, url, setRow, addTxToPool, autoRefresh, state, horiz
   }, [tick, autoRefresh]);
   useEffect(() => {
     jsonRpc2(url, "get_epoch_manager_stats").then((resp) => {
-      setRow(resp.committee_shard.shard + 1);
-      setBucket(resp.committee_shard.shard);
+      // setRow(resp.committee_info.shard + 1);
+      setCommitteeInfo(resp.committee_info);
       setHeight(resp.current_block_height);
       setEpoch(resp.current_epoch);
     }).catch((resp) => {
@@ -202,12 +201,12 @@ function ExtraInfoVN({ name, url, setRow, addTxToPool, autoRefresh, state, horiz
         gridTemplateColumns: "auto auto",
         gridTemplateRows: "auto auto auto auto auto",
       }}>
-        <div><b>Bucket</b></div>
+        <div><b>Shard Group</b></div>
         <div><b>Height</b></div>
         <div><b>Epoch</b></div>
         <div><b>Public key</b></div>
         <div><b>Peer id</b></div>
-        <div>{bucket}</div>
+        <div>{committeeInfo?.shard_group.start}-{committeeInfo?.shard_group.end_inclusive} ({committeeInfo?.num_shard_group_members} members)</div>
         <div>{height}</div>
         <div>{epoch}</div>
         <div>{publicKey}</div>
@@ -234,7 +233,6 @@ function ShowInfo(params: any) {
     horizontal,
     onReload,
   } = params;
-  const [row, setRow] = useState(1);
   // const [unprocessedTx, setUnprocessedTx] = useState([]);
   const nameInfo = name && (
     <div>
@@ -304,16 +302,15 @@ function ShowInfo(params: any) {
 
 
   return (
-    <div className="info" key={name} style={{ gridRow: row }}>
+    <div className="info" key={name}>
       {nameInfo}
       {httpInfo}
       {jrpcInfo}
       {grpcInfo}
       {showLogs && logInfo}
       {executable === Executable.ValidatorNode && node?.jrpc &&
-        <ExtraInfoVN name={name} url={node.jrpc} setRow={(new_row: any) => {
-          if (new_row != row) setRow(new_row);
-        }} addTxToPool={addTxToPool} autoRefresh={autoRefresh} state={state} horizontal={horizontal} />}
+        <ExtraInfoVN name={name} url={node.jrpc} addTxToPool={addTxToPool} autoRefresh={autoRefresh} state={state}
+                     horizontal={horizontal} />}
       {executable !== Executable.Templates &&
         <NodeControls
           isRunning={node?.is_running || false}
@@ -364,11 +361,23 @@ function ShowInfos(params: any) {
       setState((state) => ({ ...state, [partial_state.name]: partial_state.state }));
     }
   };
+
+  const sortedNodes = Object.keys(nodes).map((key) => [key, nodes[key]]);
+  sortedNodes.sort((a, b) => {
+    if (a[1].instance_id > b[1].instance_id) {
+      return 1;
+    }
+    if (a[1].instance_id < b[1].instance_id) {
+      return -1;
+    }
+    return 0;
+  });
+
   return (
     <div className="infos" style={{ display: "grid" }}>
-      {Object.keys(nodes).map((index) =>
-        <ShowInfo key={index} executable={executable} name={nodes[index].name} node={nodes[index]}
-                  logs={logs?.[`${name} ${index}`]} stdoutLogs={stdoutLogs?.[`${name} ${index}`]}
+      {sortedNodes.map(([key, node]) =>
+        <ShowInfo key={key} executable={executable} name={node.name} node={node}
+                  logs={logs?.[`${name} ${key}`]} stdoutLogs={stdoutLogs?.[`${name} ${key}`]}
                   showLogs={showLogs}
                   autoRefresh={autoRefresh} updateState={updateState} state={state} horizontal={horizontal}
                   onReload={onReload} />)}
diff --git a/applications/tari_swarm_daemon/webui/src/utils/json_rpc.tsx b/applications/tari_swarm_daemon/webui/src/utils/json_rpc.tsx
index 2b4e110d55..d4d96067ab 100644
--- a/applications/tari_swarm_daemon/webui/src/utils/json_rpc.tsx
+++ b/applications/tari_swarm_daemon/webui/src/utils/json_rpc.tsx
@@ -28,9 +28,9 @@ export async function jsonRpc(method: string, args: any = {}) {
 
   json_id += 1;
 
-  const address = import.meta.env.VITE_DAEMON_JRPC_ADDRESS || "";
+  const address = import.meta.env.VITE_JSON_RPC_ADDRESS || import.meta.env.VITE_JRPC_ADDRESS || "/json_rpc";
   const headers: { [key: string]: string } = { "Content-Type": "application/json" };
-  const response = await fetch(`${address}/json_rpc`, {
+  const response = await fetch(address, {
     method: "POST",
     body: JSON.stringify({
       method: method,
diff --git a/applications/tari_validator_node/src/bootstrap.rs b/applications/tari_validator_node/src/bootstrap.rs
index 9e61317893..39eb746367 100644
--- a/applications/tari_validator_node/src/bootstrap.rs
+++ b/applications/tari_validator_node/src/bootstrap.rs
@@ -177,8 +177,6 @@ pub async fn spawn_services(
     handles.push(join_handle);
 
     info!(target: LOG_TARGET, "Message logging initializing");
-    // Spawn messaging
-    let message_logger = SqliteMessageLogger::new(config.validator_node.data_dir.join("message_log.sqlite"));
 
     info!(target: LOG_TARGET, "State store initializing");
     // Connect to shard db
@@ -230,6 +228,7 @@ pub async fn spawn_services(
     };
 
     // Messaging
+    let message_logger = SqliteMessageLogger::new(config.validator_node.data_dir.join("message_log.sqlite"));
     let local_address = PeerAddress::from(keypair.public_key().clone());
     let (loopback_sender, loopback_receiver) = mpsc::unbounded_channel();
     let inbound_messaging = ConsensusInboundMessaging::new(
diff --git a/applications/tari_validator_node/src/consensus/block_transaction_executor.rs b/applications/tari_validator_node/src/consensus/block_transaction_executor.rs
index 94523544b6..fa2a4eb187 100644
--- a/applications/tari_validator_node/src/consensus/block_transaction_executor.rs
+++ b/applications/tari_validator_node/src/consensus/block_transaction_executor.rs
@@ -85,33 +85,6 @@ where
     ) -> Result<ExecutedTransaction, BlockTransactionExecutorError> {
         let id = *transaction.id();
 
-        // if let Some(abort_reason) = transaction.abort_reason() {
-        //     // TODO: Hacky - if a transaction uses DOWNed/non-existent inputs we error here. This changes the hard
-        //     // error to a propose REJECT. So that we have involved shards, we use the inputs as resolved inputs and
-        //     // assume v0 if version is not provided.
-        //     let inputs = transaction
-        //         .transaction()
-        //         .all_inputs_iter()
-        //         .map(|input| VersionedSubstateId::new(input.substate_id, input.version.unwrap_or(0)))
-        //         .map(|id| VersionedSubstateIdLockIntent::new(id, SubstateLockFlag::Write))
-        //         .collect();
-        //     return Ok(ExecutedTransaction::new(
-        //         transaction.into_transaction(),
-        //         ExecuteResult {
-        //             finalize: FinalizeResult {
-        //                 transaction_hash: id.into_array().into(),
-        //                 events: vec![],
-        //                 logs: vec![],
-        //                 execution_results: vec![],
-        //                 result: TransactionResult::Reject(abort_reason.clone()),
-        //                 fee_receipt: Default::default(),
-        //             },
-        //         },
-        //         inputs,
-        //         vec![],
-        //         Duration::from_secs(0),
-        //     ));
-        // }
         info!(target: LOG_TARGET, "Transaction {} executing. Inputs: {:?}", id, resolved_inputs);
 
         // Create a memory db with all the input substates, needed for the transaction execution
diff --git a/applications/tari_validator_node/src/json_rpc/handlers.rs b/applications/tari_validator_node/src/json_rpc/handlers.rs
index cdcd51fdbb..41a37da06d 100644
--- a/applications/tari_validator_node/src/json_rpc/handlers.rs
+++ b/applications/tari_validator_node/src/json_rpc/handlers.rs
@@ -588,7 +588,7 @@ impl JsonRpcHandlers {
                     ),
                 )
             })?;
-        let committee_shard = self
+        let committee_info = self
             .epoch_manager
             .get_local_committee_info(current_epoch)
             .await
@@ -611,8 +611,8 @@ impl JsonRpcHandlers {
             current_epoch,
             current_block_height,
             current_block_hash,
-            is_valid: committee_shard.is_some(),
-            committee_info: committee_shard,
+            is_valid: committee_info.is_some(),
+            committee_info,
         };
         Ok(JsonRpcResponse::success(answer_id, response))
     }
diff --git a/applications/tari_validator_node/src/p2p/services/mempool/gossip.rs b/applications/tari_validator_node/src/p2p/services/mempool/gossip.rs
index 79ad251106..09ac9cd587 100644
--- a/applications/tari_validator_node/src/p2p/services/mempool/gossip.rs
+++ b/applications/tari_validator_node/src/p2p/services/mempool/gossip.rs
@@ -212,5 +212,9 @@ impl MempoolGossip<PeerAddress> {
 }
 
 fn shard_group_to_topic(shard_group: ShardGroup) -> String {
-    format!("transactions-{}-{}", shard_group.start(), shard_group.end())
+    format!(
+        "transactions-{}-{}",
+        shard_group.start().as_u32(),
+        shard_group.end().as_u32()
+    )
 }
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 e56f4d3bc8..fe9c6e92d8 100644
--- a/applications/tari_validator_node/src/p2p/services/mempool/service.rs
+++ b/applications/tari_validator_node/src/p2p/services/mempool/service.rs
@@ -161,9 +161,9 @@ where TValidator: Validator<Transaction, Context = (), Error = TransactionValida
         if self.transaction_exists(transaction.id())? {
             return Ok(());
         }
-        debug!(
+        info!(
             target: LOG_TARGET,
-            "Received NEW transaction from local: {} {:?}",
+            "🎱 Received NEW transaction from local: {} {:?}",
             transaction.id(),
             transaction
         );
@@ -304,8 +304,6 @@ where TValidator: Validator<Transaction, Context = (), Error = TransactionValida
                 .await
                 .map_err(|_| MempoolError::ConsensusChannelClosed)?;
 
-            // self.queue_transaction_for_execution(transaction.clone(), current_epoch, should_propagate, sender_shard);
-
             if should_propagate {
                 // This validator is involved, we to send the transaction to local replicas
                 if let Err(e) = self
@@ -368,7 +366,10 @@ where TValidator: Validator<Transaction, Context = (), Error = TransactionValida
             if should_propagate {
                 // This validator is not involved, so we forward the transaction to f + 1 replicas per distinct shard
                 // per input shard ID because we may be the only validator that has received this transaction.
-                let substate_addresses = transaction.versioned_input_addresses_iter().collect();
+                let substate_addresses = transaction
+                    .all_inputs_iter()
+                    .map(|input| input.or_zero_version().to_substate_address())
+                    .collect();
                 if let Err(e) = self
                     .gossip
                     .gossip_to_foreign_replicas(current_epoch, substate_addresses, NewTransactionMessage {
diff --git a/applications/tari_validator_node/src/p2p/services/messaging/outbound.rs b/applications/tari_validator_node/src/p2p/services/messaging/outbound.rs
index cca4537c84..3cb36f3dab 100644
--- a/applications/tari_validator_node/src/p2p/services/messaging/outbound.rs
+++ b/applications/tari_validator_node/src/p2p/services/messaging/outbound.rs
@@ -124,7 +124,7 @@ impl<TMsgLogger: MessageLogger + Send> tari_consensus::traits::OutboundMessaging
 
         for to in &theirs {
             self.msg_logger
-                .log_outbound_message("broadcast", &to.to_string(), message.as_type_str(), "", &message);
+                .log_outbound_message("multicast", &to.to_string(), message.as_type_str(), "", &message);
         }
 
         self.networking
diff --git a/dan_layer/common_types/src/committee.rs b/dan_layer/common_types/src/committee.rs
index 91255925dd..81383ca5d7 100644
--- a/dan_layer/common_types/src/committee.rs
+++ b/dan_layer/common_types/src/committee.rs
@@ -6,6 +6,7 @@ use std::{borrow::Borrow, cmp, ops::RangeInclusive};
 use rand::{rngs::OsRng, seq::SliceRandom};
 use serde::{Deserialize, Serialize};
 use tari_common_types::types::PublicKey;
+use tari_engine_types::substate::SubstateId;
 
 use crate::{shard::Shard, Epoch, NumPreshards, ShardGroup, SubstateAddress};
 
@@ -203,7 +204,7 @@ impl CommitteeInfo {
         (len - 1) / 3
     }
 
-    pub fn num_shards(&self) -> NumPreshards {
+    pub fn num_preshards(&self) -> NumPreshards {
         self.num_shards
     }
 
@@ -221,6 +222,13 @@ impl CommitteeInfo {
         self.shard_group.contains(&s)
     }
 
+    pub fn includes_substate_id(&self, substate_id: &SubstateId) -> bool {
+        // version doesnt affect shard
+        let addr = SubstateAddress::from_substate_id(substate_id, 0);
+        let shard = addr.to_shard(self.num_shards);
+        self.shard_group.contains(&shard)
+    }
+
     pub fn includes_all_substate_addresses<I: IntoIterator<Item = B>, B: Borrow<SubstateAddress>>(
         &self,
         substate_addresses: I,
diff --git a/dan_layer/consensus/src/hotstuff/common.rs b/dan_layer/consensus/src/hotstuff/common.rs
index 28200cdb00..2743181023 100644
--- a/dan_layer/consensus/src/hotstuff/common.rs
+++ b/dan_layer/consensus/src/hotstuff/common.rs
@@ -10,7 +10,14 @@ use indexmap::IndexMap;
 use log::*;
 use tari_common::configuration::Network;
 use tari_common_types::types::FixedHash;
-use tari_dan_common_types::{committee::Committee, shard::Shard, Epoch, NodeAddressable, NodeHeight, ShardGroup};
+use tari_dan_common_types::{
+    committee::{Committee, CommitteeInfo},
+    shard::Shard,
+    Epoch,
+    NodeAddressable,
+    NodeHeight,
+    ShardGroup,
+};
 use tari_dan_storage::{
     consensus_models::{
         Block,
@@ -25,6 +32,7 @@ use tari_dan_storage::{
     StateStoreWriteTransaction,
     StorageError,
 };
+use tari_engine_types::substate::SubstateDiff;
 use tari_state_tree::{Hash, JellyfishMerkleTree, StateTreeError};
 
 use crate::{
@@ -241,3 +249,19 @@ where
 
     Ok(checkpoint)
 }
+
+pub(crate) fn filter_diff_for_committee(committee_info: &CommitteeInfo, diff: &SubstateDiff) -> SubstateDiff {
+    let mut filtered_diff = SubstateDiff::new();
+    filtered_diff
+        .extend_up(
+            diff.up_iter()
+                .filter(|(id, _)| committee_info.includes_substate_id(id))
+                .cloned(),
+        )
+        .extend_down(
+            diff.down_iter()
+                .filter(|(id, _)| committee_info.includes_substate_id(id))
+                .cloned(),
+        );
+    filtered_diff
+}
diff --git a/dan_layer/consensus/src/hotstuff/error.rs b/dan_layer/consensus/src/hotstuff/error.rs
index 65d3928c3f..ec51ae94b6 100644
--- a/dan_layer/consensus/src/hotstuff/error.rs
+++ b/dan_layer/consensus/src/hotstuff/error.rs
@@ -230,4 +230,9 @@ pub enum ProposalValidationError {
         transaction_id: TransactionId,
         details: String,
     },
+    #[error(
+        "Foreign node submitted an foreign proposal {block_id} that did not contain any transaction evidence for this \
+         node"
+    )]
+    NoTransactionsInCommittee { block_id: BlockId },
 }
diff --git a/dan_layer/consensus/src/hotstuff/on_message_validate.rs b/dan_layer/consensus/src/hotstuff/on_message_validate.rs
index 8901dca557..ab6fb47894 100644
--- a/dan_layer/consensus/src/hotstuff/on_message_validate.rs
+++ b/dan_layer/consensus/src/hotstuff/on_message_validate.rs
@@ -5,21 +5,20 @@ use std::collections::HashSet;
 
 use log::*;
 use tari_common_types::types::PublicKey;
-use tari_dan_common_types::{Epoch, NodeHeight};
+use tari_dan_common_types::{committee::CommitteeInfo, Epoch, NodeHeight};
 use tari_dan_storage::{
-    consensus_models::{Block, BlockId, TransactionRecord},
+    consensus_models::{Block, BlockId, ForeignParkedProposal, TransactionRecord},
     StateStore,
     StateStoreWriteTransaction,
 };
-use tari_epoch_manager::EpochManagerReader;
 use tari_transaction::TransactionId;
 use tokio::sync::broadcast;
 
 use super::config::HotstuffConfig;
 use crate::{
     block_validations,
-    hotstuff::{error::HotStuffError, HotstuffEvent},
-    messages::{HotstuffMessage, MissingTransactionsRequest, ProposalMessage},
+    hotstuff::{error::HotStuffError, HotstuffEvent, ProposalValidationError},
+    messages::{ForeignProposalMessage, HotstuffMessage, MissingTransactionsRequest, ProposalMessage},
     traits::{ConsensusSpec, OutboundMessaging},
 };
 
@@ -64,23 +63,15 @@ impl<TConsensusSpec: ConsensusSpec> OnMessageValidate<TConsensusSpec> {
     pub async fn handle(
         &mut self,
         current_height: NodeHeight,
+        local_committee_info: &CommitteeInfo,
         from: TConsensusSpec::Addr,
         msg: HotstuffMessage,
     ) -> Result<MessageValidationResult<TConsensusSpec::Addr>, HotStuffError> {
         match msg {
             HotstuffMessage::Proposal(msg) => self.process_local_proposal(current_height, from, msg).await,
             HotstuffMessage::ForeignProposal(proposal) => {
-                if let Err(err) = self.check_proposal(&proposal.block).await {
-                    return Ok(MessageValidationResult::Invalid {
-                        from,
-                        message: HotstuffMessage::ForeignProposal(proposal),
-                        err,
-                    });
-                }
-                Ok(MessageValidationResult::Ready {
-                    from,
-                    message: HotstuffMessage::ForeignProposal(proposal),
-                })
+                self.process_foreign_proposal(local_committee_info, from, proposal)
+                    .await
             },
             HotstuffMessage::MissingTransactionsResponse(msg) => {
                 if !self.active_missing_transaction_requests.remove_element(&msg.request_id) {
@@ -163,14 +154,14 @@ impl<TConsensusSpec: ConsensusSpec> OnMessageValidate<TConsensusSpec> {
             });
         }
 
-        self.handle_missing_transactions(from, block).await
+        self.handle_missing_transactions_local_block(from, block).await
     }
 
-    pub async fn update_parked_blocks(
+    pub fn update_local_parked_blocks(
         &self,
         current_height: NodeHeight,
         transaction_id: &TransactionId,
-    ) -> Result<Option<(TConsensusSpec::Addr, HotstuffMessage)>, HotStuffError> {
+    ) -> Result<Option<ProposalMessage>, HotStuffError> {
         let maybe_unparked_block = self
             .store
             .with_write_tx(|tx| tx.missing_transactions_remove(current_height, transaction_id))?;
@@ -181,19 +172,28 @@ impl<TConsensusSpec: ConsensusSpec> OnMessageValidate<TConsensusSpec> {
 
         info!(target: LOG_TARGET, "♻️ all transactions for block {unparked_block} are ready for consensus");
 
-        let vn = self
-            .epoch_manager
-            .get_validator_node_by_public_key(unparked_block.epoch(), unparked_block.proposed_by())
-            .await?;
-
         let _ignore = self.tx_events.send(HotstuffEvent::ParkedBlockReady {
             block: unparked_block.as_leaf_block(),
         });
 
-        Ok(Some((
-            vn.address,
-            HotstuffMessage::Proposal(ProposalMessage { block: unparked_block }),
-        )))
+        Ok(Some(ProposalMessage { block: unparked_block }))
+    }
+
+    pub fn update_foreign_parked_blocks(
+        &self,
+        transaction_id: &TransactionId,
+    ) -> Result<Vec<ForeignParkedProposal>, HotStuffError> {
+        let unparked_foreign_blocks = self
+            .store
+            .with_write_tx(|tx| ForeignParkedProposal::remove_by_transaction_id(tx, transaction_id))?;
+
+        if unparked_foreign_blocks.is_empty() {
+            return Ok(vec![]);
+        };
+
+        info!(target: LOG_TARGET, "♻️ all transactions for {} foreign block(s) are ready for consensus", unparked_foreign_blocks.len());
+
+        Ok(unparked_foreign_blocks)
     }
 
     async fn check_proposal(&self, block: &Block) -> Result<(), HotStuffError> {
@@ -208,7 +208,7 @@ impl<TConsensusSpec: ConsensusSpec> OnMessageValidate<TConsensusSpec> {
         Ok(())
     }
 
-    async fn handle_missing_transactions(
+    async fn handle_missing_transactions_local_block(
         &mut self,
         from: TConsensusSpec::Addr,
         block: Block,
@@ -270,6 +270,96 @@ impl<TConsensusSpec: ConsensusSpec> OnMessageValidate<TConsensusSpec> {
 
         Ok(missing_tx_ids)
     }
+
+    async fn process_foreign_proposal(
+        &mut self,
+        local_committee_info: &CommitteeInfo,
+        from: TConsensusSpec::Addr,
+        msg: ForeignProposalMessage,
+    ) -> Result<MessageValidationResult<TConsensusSpec::Addr>, HotStuffError> {
+        info!(
+            target: LOG_TARGET,
+            "🧩 new unvalidated FOREIGN PROPOSAL message {} from {}",
+            msg,
+            from
+        );
+
+        if msg.block.commands().is_empty() {
+            warn!(
+                target: LOG_TARGET,
+                "❌ Foreign proposal block {} is empty therefore it cannot involve the local shard group", msg.block
+            );
+            let block_id = *msg.block.id();
+            return Ok(MessageValidationResult::Invalid {
+                from,
+                message: HotstuffMessage::ForeignProposal(msg),
+                err: HotStuffError::ProposalValidationError(ProposalValidationError::NoTransactionsInCommittee {
+                    block_id,
+                }),
+            });
+        }
+
+        if let Err(err) = self.check_proposal(&msg.block).await {
+            return Ok(MessageValidationResult::Invalid {
+                from,
+                message: HotstuffMessage::ForeignProposal(msg),
+                err,
+            });
+        }
+
+        self.store.with_write_tx(|tx| {
+            let mut all_involved_transactions = msg
+                .block
+                .all_transaction_ids_in_committee(local_committee_info)
+                .peekable();
+            // CASE: all foreign proposals must include evidence
+            if all_involved_transactions.peek().is_none() {
+                warn!(
+                    target: LOG_TARGET,
+                    "❌ Foreign Block {} has no transactions involving our committee", msg.block
+                );
+                // drop the borrow of msg.block
+                drop(all_involved_transactions);
+                let block_id = *msg.block.id();
+                return Ok(MessageValidationResult::Invalid {
+                    from,
+                    message: HotstuffMessage::ForeignProposal(msg),
+                    err: HotStuffError::ProposalValidationError(ProposalValidationError::NoTransactionsInCommittee {
+                        block_id,
+                    }),
+                });
+            }
+
+            let missing_tx_ids = TransactionRecord::get_missing(&**tx, all_involved_transactions)?;
+
+            if missing_tx_ids.is_empty() {
+                debug!(
+                    target: LOG_TARGET,
+                    "✅ Foreign Block {} has no missing transactions", msg.block
+                );
+                return Ok(MessageValidationResult::Ready {
+                    from,
+                    message: HotstuffMessage::ForeignProposal(msg),
+                });
+            }
+
+            info!(
+                target: LOG_TARGET,
+                "⏳ Foreign Block {} has {} missing transactions", msg.block, missing_tx_ids.len(),
+            );
+
+            let parked_block = ForeignParkedProposal::from(msg);
+            parked_block.insert(tx)?;
+            parked_block.add_missing_transactions(tx, &missing_tx_ids)?;
+
+            Ok(MessageValidationResult::ParkedProposal {
+                block_id: *parked_block.block.id(),
+                epoch: parked_block.block.epoch(),
+                proposed_by: parked_block.block.proposed_by().clone(),
+                missing_txs: missing_tx_ids,
+            })
+        })
+    }
 }
 
 #[derive(Debug)]
diff --git a/dan_layer/consensus/src/hotstuff/on_propose.rs b/dan_layer/consensus/src/hotstuff/on_propose.rs
index 17eb596230..e6626a70b1 100644
--- a/dan_layer/consensus/src/hotstuff/on_propose.rs
+++ b/dan_layer/consensus/src/hotstuff/on_propose.rs
@@ -50,6 +50,7 @@ use crate::{
     hotstuff::{
         calculate_state_merkle_root,
         error::HotStuffError,
+        filter_diff_for_committee,
         substate_store::PendingSubstateStore,
         transaction_manager::{
             ConsensusTransactionManager,
@@ -171,12 +172,14 @@ where TConsensusSpec: ConsensusSpec
             )?;
 
             // Add executions for this block
-            debug!(
-                target: LOG_TARGET,
-                "Adding {} executed transaction(s) to block {}",
-                executed_transactions.len(),
-                next_block.id()
-            );
+            if !executed_transactions.is_empty() {
+                debug!(
+                    target: LOG_TARGET,
+                    "Saving {} executed transaction(s) for block {}",
+                    executed_transactions.len(),
+                    next_block.id()
+                );
+            }
             for executed in executed_transactions.into_values() {
                 executed.for_block(*next_block.id()).insert_if_required(tx)?;
             }
@@ -268,11 +271,7 @@ where TConsensusSpec: ConsensusSpec
                 self.get_current_transaction_atom(local_committee_info, &mut tx_rec)?,
             ))),
             TransactionPoolStage::LocalAccepted => {
-                if tx_rec.current_decision().is_commit() {
-                    Ok(Some(Command::AllAccept(tx_rec.get_current_transaction_atom())))
-                } else {
-                    Ok(Some(Command::SomeAccept(tx_rec.get_current_transaction_atom())))
-                }
+                self.accept_transaction(tx, parent_block, &mut tx_rec, local_committee_info, substate_store)
             },
             // Not reachable as there is nothing to propose for these stages. To confirm that all local nodes
             // agreed with the Accept, more (possibly empty) blocks with QCs will be
@@ -433,7 +432,7 @@ where TConsensusSpec: ConsensusSpec
             )
             .map_err(|e| HotStuffError::TransactionExecutorError(e.to_string()))?;
 
-        let command = match prepared {
+        let command = match prepared.clone() {
             PreparedTransaction::LocalOnly(LocalPreparedTransaction::Accept(executed)) => {
                 let execution = executed.into_execution();
                 // Update the decision so that we can propose it
@@ -508,7 +507,7 @@ where TConsensusSpec: ConsensusSpec
                             // CASE: All local inputs were resolved. We need to continue with consensus to get the
                             // foreign inputs/outputs.
                             tx_rec.set_local_decision(Decision::Commit);
-                            // Set partial evidence for local inputs using what we know.
+                            // Set partial evidence using local inputs and known outputs.
                             tx_rec.set_evidence(multishard.to_initial_evidence());
                         }
                     },
@@ -548,10 +547,10 @@ where TConsensusSpec: ConsensusSpec
             self.execute_transaction(tx, &parent_block.block_id, parent_block.epoch, tx_rec.transaction_id())?;
 
         // Try to lock all local outputs
-        let local_outputs = execution
-            .resulting_outputs()
-            .iter()
-            .filter(|o| local_committee_info.includes_substate_address(&o.to_substate_address()));
+        let local_outputs = execution.resulting_outputs().iter().filter(|o| {
+            o.substate_id().is_transaction_receipt() ||
+                local_committee_info.includes_substate_address(&o.to_substate_address())
+        });
         match substate_store.try_lock_all(*tx_rec.transaction_id(), local_outputs, false) {
             Ok(()) => {},
             Err(err) => {
@@ -576,20 +575,44 @@ where TConsensusSpec: ConsensusSpec
         tx_rec.update_from_execution(&execution);
 
         let atom = self.get_current_transaction_atom(local_committee_info, tx_rec)?;
-        if atom.decision.is_commit() {
-            let diff = execution.result().finalize.accept().ok_or_else(|| {
-                HotStuffError::InvariantError(format!(
-                    "local_accept_transaction: Transaction {} has COMMIT decision but execution failed when proposing",
-                    tx_rec.transaction_id(),
-                ))
-            })?;
-            substate_store.put_diff(*tx_rec.transaction_id(), diff)?;
-        }
-
         executed_transactions.insert(*tx_rec.transaction_id(), execution);
         Ok(Some(Command::LocalAccept(atom)))
     }
 
+    fn accept_transaction(
+        &self,
+        tx: &<TConsensusSpec::StateStore as StateStore>::ReadTransaction<'_>,
+        parent_block: &LeafBlock,
+        tx_rec: &mut TransactionPoolRecord,
+        local_committee_info: &CommitteeInfo,
+        substate_store: &mut PendingSubstateStore<TConsensusSpec::StateStore>,
+    ) -> Result<Option<Command>, HotStuffError> {
+        if tx_rec.current_decision().is_abort() {
+            return Ok(Some(Command::SomeAccept(tx_rec.get_current_transaction_atom())));
+        }
+
+        let execution =
+            BlockTransactionExecution::get_pending_for_block(tx, tx_rec.transaction_id(), &parent_block.block_id)
+                .optional()?
+                .ok_or_else(|| {
+                    HotStuffError::InvariantError(format!(
+                        "accept_transaction: Transaction {} has COMMIT decision but execution is missing",
+                        tx_rec.transaction_id(),
+                    ))
+                })?;
+        let diff = execution.result().finalize.accept().ok_or_else(|| {
+            HotStuffError::InvariantError(format!(
+                "local_accept_transaction: Transaction {} has COMMIT decision but execution failed when proposing",
+                tx_rec.transaction_id(),
+            ))
+        })?;
+        substate_store.put_diff(
+            *tx_rec.transaction_id(),
+            &filter_diff_for_committee(local_committee_info, diff),
+        )?;
+        Ok(Some(Command::AllAccept(tx_rec.get_current_transaction_atom())))
+    }
+
     fn get_current_transaction_atom(
         &self,
         local_committee_info: &CommitteeInfo,
@@ -616,21 +639,27 @@ where TConsensusSpec: ConsensusSpec
         current_epoch: Epoch,
         transaction_id: &TransactionId,
     ) -> Result<TransactionExecution, HotStuffError> {
-        info!(
-            target: LOG_TARGET,
-            "👨‍🔧 PROPOSE: Executing transaction {}",
-            transaction_id,
-        );
         let transaction = TransactionRecord::get(tx, transaction_id)?;
         // Might have been executed already if all inputs are local
         if let Some(execution) =
             BlockTransactionExecution::get_pending_for_block(tx, transaction_id, parent_block_id).optional()?
         {
+            info!(
+                target: LOG_TARGET,
+                "👨‍🔧 PROPOSE: Using existing transaction execution {} ({})",
+                transaction_id, execution.execution.decision(),
+            );
             return Ok(execution.into_transaction_execution());
         }
 
         let pledged = PledgedTransaction::load_pledges(tx, transaction)?;
 
+        info!(
+            target: LOG_TARGET,
+            "👨‍🔧 PROPOSE: Executing transaction {} (pledges: {} local, {} foreign)",
+            transaction_id, pledged.local_pledges.len(), pledged.foreign_pledges.len(),
+        );
+
         let executed = self
             .transaction_manager
             .execute(current_epoch, pledged)
@@ -645,7 +674,7 @@ pub fn get_non_local_shards(diff: &[SubstateChange], local_committee_info: &Comm
         .map(|ch| {
             ch.versioned_substate_id()
                 .to_substate_address()
-                .to_shard(local_committee_info.num_shards())
+                .to_shard(local_committee_info.num_preshards())
         })
         .filter(|shard| local_committee_info.shard_group().contains(shard))
         .collect()
diff --git a/dan_layer/consensus/src/hotstuff/on_ready_to_vote_on_local_block.rs b/dan_layer/consensus/src/hotstuff/on_ready_to_vote_on_local_block.rs
index 4d1faa6f65..51e8c1a74e 100644
--- a/dan_layer/consensus/src/hotstuff/on_ready_to_vote_on_local_block.rs
+++ b/dan_layer/consensus/src/hotstuff/on_ready_to_vote_on_local_block.rs
@@ -40,6 +40,7 @@ use crate::{
         calculate_state_merkle_root,
         error::HotStuffError,
         event::HotstuffEvent,
+        filter_diff_for_committee,
         substate_store::{PendingSubstateStore, ShardedStateTree},
         transaction_manager::{
             ConsensusTransactionManager,
@@ -93,7 +94,7 @@ where TConsensusSpec: ConsensusSpec
     pub fn handle(
         &mut self,
         valid_block: &ValidBlock,
-        local_committee_info: CommitteeInfo,
+        local_committee_info: &CommitteeInfo,
         can_propose_epoch_end: bool,
     ) -> Result<BlockDecision, HotStuffError> {
         debug!(
@@ -104,7 +105,7 @@ where TConsensusSpec: ConsensusSpec
 
         self.store.with_write_tx(|tx| {
             let mut change_set =
-                self.decide_on_block(&**tx, &local_committee_info, valid_block, can_propose_epoch_end)?;
+                self.decide_on_block(&**tx, local_committee_info, valid_block, can_propose_epoch_end)?;
 
             let mut locked_blocks = Vec::new();
             let mut finalized_transactions = Vec::new();
@@ -121,7 +122,7 @@ where TConsensusSpec: ConsensusSpec
                         self.on_lock_block(tx, locked, block)
                     },
                     |tx, last_exec, commit_block| {
-                        let committed = self.on_commit(tx, last_exec, commit_block, &local_committee_info)?;
+                        let committed = self.on_commit(tx, last_exec, commit_block, local_committee_info)?;
                         if commit_block.is_epoch_end() {
                             end_of_epoch = Some(commit_block.epoch());
                         }
@@ -133,7 +134,7 @@ where TConsensusSpec: ConsensusSpec
                 )?;
 
                 if !leaf_block.is_justified() {
-                    self.process_newly_justified_block(tx, leaf_block, &mut change_set)?;
+                    self.process_newly_justified_block(tx, leaf_block, local_committee_info, &mut change_set)?;
                 }
 
                 valid_block.block().as_last_voted().set(tx)?;
@@ -155,92 +156,120 @@ where TConsensusSpec: ConsensusSpec
         &self,
         tx: &mut <TConsensusSpec::StateStore as StateStore>::WriteTransaction<'_>,
         mut new_leaf_block: Block,
+        local_committee_info: &CommitteeInfo,
         change_set: &mut ProposedBlockChangeSet,
     ) -> Result<(), HotStuffError> {
+        info!(
+            target: LOG_TARGET,
+            "✅ New leaf block {} is justified. Updating evidence for transactions",
+            new_leaf_block,
+        );
         new_leaf_block.set_as_justified(tx)?;
 
         let leaf = new_leaf_block.as_leaf_block();
-        for cmd in new_leaf_block.into_commands() {
-            // CASE: This code checks if the new leaf block causes the transaction to be ready.
-            // For example, suppose a transaction is LocalPrepared in the currently proposed block, however it is not
-            // yet the leaf block (because it has not been justified). If we then receive the foreign LocalPrepared for
-            // this transaction, we evaluate the foreign LocalPrepare using the transaction state as it "was" without
-            // considering data from the as yet unjustified block. This means that we do not recognise that
-            // the transaction is ready for AllPrepared, and we never propose it. This code reevaluates the new leaf
-            // blocks and sets any transactions to ready that have the required evidence.
-            match cmd {
-                Command::LocalPrepare(atom) => {
-                    let Some(pool_tx) = self.transaction_pool.get(tx, leaf, atom.id()).optional()? else {
-                        return Err(HotStuffError::InvariantError(format!(
-                            "Transaction {} in newly justified block {} not found in the pool",
-                            atom.id(),
-                            leaf,
-                        )));
-                    };
+        let justify_id = *new_leaf_block.justify().id();
+        for cmd in new_leaf_block.commands() {
+            let Some(atom) = cmd.progressing() else {
+                continue;
+            };
+
+            if let Some(update_mut) = change_set.next_update_mut(atom.id()) {
+                // The leaf block already approved finalising this transaction (i.e. the justify block proposed
+                // LocalAccept, the leaf proposed (some|all)Accept therefore we already have all evidence). This
+                // transaction will not be proposed again and will be finalised.
+                if update_mut.stage.is_finalising() {
+                    continue;
+                }
+
+                update_mut
+                    .evidence_mut()
+                    .add_qc_evidence(local_committee_info, justify_id);
 
-                    if !pool_tx.is_ready() && pool_tx.evidence().all_addresses_justified() {
+                if !update_mut.is_ready {
+                    let local_prepare_is_justified =
+                        update_mut.stage.is_local_prepared() && update_mut.evidence().all_input_addresses_justified();
+                    let local_accept_is_justified =
+                        update_mut.stage.is_local_accepted() && update_mut.evidence().all_addresses_justified();
+                    if local_prepare_is_justified {
                         info!(
                             target: LOG_TARGET,
                             "✅ All inputs justified for transaction {} in block {} is now ready for AllPrepared",
                             atom.id(),
                             leaf,
                         );
-                        // TODO: this is a hack to allow the update to be modified if the current block already has a
-                        // transaction update
-                        if let Some(update_mut) = change_set.next_update_mut(pool_tx.transaction_id()) {
-                            if update_mut.stage.is_local_prepared() {
-                                update_mut.is_ready = true;
-                            }
-                        } else {
-                            change_set.set_next_transaction_update(
-                                &pool_tx,
-                                TransactionPoolStage::LocalPrepared,
-                                true,
-                            )?;
-                        }
+                        update_mut.is_ready = true;
+                    } else if local_accept_is_justified {
+                        info!(
+                            target: LOG_TARGET,
+                            "✅ All inputs justified for transaction {} in block {} is now ready for AllAccepted",
+                            atom.id(),
+                            leaf,
+                        );
+                        update_mut.is_ready = true;
+                    } else {
+                        // Nothing - we've updated the evidence and is_ready remains false
+                        debug!(
+                            target: LOG_TARGET,
+                            "Transaction {} stage: {} still not ready",
+                            atom.id(),
+                            update_mut.stage
+                        );
                     }
-                },
-                Command::LocalAccept(atom) => {
-                    let Some(pool_tx) = self.transaction_pool.get(tx, leaf, atom.id()).optional()? else {
-                        return Err(HotStuffError::InvariantError(format!(
-                            "Transaction {} in newly justified block {} not found in the pool",
+                }
+            } else {
+                // No update from current leaf, so the current pool data is the latest
+                let Some(mut pool_tx) = self.transaction_pool.get(tx, leaf, atom.id()).optional()? else {
+                    return Err(HotStuffError::InvariantError(format!(
+                        "Transaction {} in newly justified block {} not found in the pool",
+                        atom.id(),
+                        leaf,
+                    )));
+                };
+
+                pool_tx.add_qc_evidence(local_committee_info, justify_id);
+
+                if pool_tx.is_ready() {
+                    change_set.set_next_transaction_update(&pool_tx, pool_tx.current_stage(), true)?;
+                } else {
+                    // CASE: This code checks if the new leaf block causes the transaction to be ready.
+                    // For example, suppose a transaction is LocalPrepared in the currently proposed block, however it
+                    // is not yet the leaf block (because it has not been justified). If we then
+                    // receive the foreign LocalPrepared for this transaction, we evaluate the
+                    // foreign LocalPrepare using the transaction state as it "was" without
+                    // considering data from the as yet unjustified block. This means that we do not
+                    // recognise that the transaction is ready for AllPrepared, and we never propose
+                    // it. This code reevaluates the new leaf blocks and sets any transactions to
+                    // ready that have the required evidence.
+                    let local_prepare_is_justified = cmd
+                        .local_prepare()
+                        .map(|_| pool_tx.evidence().all_input_addresses_justified())
+                        .unwrap_or(false);
+                    let local_accept_is_justified = cmd
+                        .local_accept()
+                        .map(|_| pool_tx.evidence().all_addresses_justified())
+                        .unwrap_or(false);
+                    let is_ready = local_prepare_is_justified || local_accept_is_justified;
+
+                    // Some logs
+                    if local_prepare_is_justified {
+                        info!(
+                            target: LOG_TARGET,
+                            "✅ All inputs justified for transaction {} in block {} is now ready for AllPrepared",
                             atom.id(),
                             leaf,
-                        )));
-                    };
-
-                    if !pool_tx.is_ready() && pool_tx.evidence().all_addresses_justified() {
+                        );
+                    } else if local_accept_is_justified {
                         info!(
                             target: LOG_TARGET,
                             "✅ All inputs justified for transaction {} in block {} is now ready for AllAccepted",
                             atom.id(),
                             leaf,
                         );
-                        // TODO: this is a hack to allow the update to be modified after the fact. This should be
-                        // removed.
-                        if let Some(update_mut) = change_set.next_update_mut(pool_tx.transaction_id()) {
-                            if update_mut.stage.is_local_accepted() {
-                                update_mut.is_ready = true;
-                            }
-                        } else {
-                            change_set.set_next_transaction_update(
-                                &pool_tx,
-                                TransactionPoolStage::LocalAccepted,
-                                true,
-                            )?;
-                        }
+                    } else {
+                        // Nothing - we'll still update the evidence with is_ready = false
                     }
-                },
-                Command::Prepare(_) |
-                Command::AllPrepare(_) |
-                Command::SomePrepare(_) |
-                Command::AllAccept(_) |
-                Command::SomeAccept(_) |
-                Command::ForeignProposal(_) |
-                Command::EndEpoch |
-                Command::LocalOnly(_) => {
-                    // Nothing to do
-                },
+                    change_set.set_next_transaction_update(&pool_tx, pool_tx.current_stage(), is_ready)?;
+                }
             }
         }
 
@@ -330,35 +359,17 @@ where TConsensusSpec: ConsensusSpec
                     }
                 },
                 Command::LocalPrepare(atom) => {
-                    if !self.evaluate_local_prepare_command(
-                        tx,
-                        block,
-                        atom,
-                        local_committee_info,
-                        &mut proposed_block_change_set,
-                    )? {
+                    if !self.evaluate_local_prepare_command(tx, block, atom, &mut proposed_block_change_set)? {
                         return Ok(proposed_block_change_set.no_vote());
                     }
                 },
                 Command::AllPrepare(atom) => {
-                    if !self.evaluate_all_prepare_command(
-                        tx,
-                        block,
-                        atom,
-                        local_committee_info,
-                        &mut proposed_block_change_set,
-                    )? {
+                    if !self.evaluate_all_prepare_command(tx, block, atom, &mut proposed_block_change_set)? {
                         return Ok(proposed_block_change_set.no_vote());
                     }
                 },
                 Command::SomePrepare(atom) => {
-                    if !self.evaluate_some_prepare_command(
-                        tx,
-                        block,
-                        atom,
-                        local_committee_info,
-                        &mut proposed_block_change_set,
-                    )? {
+                    if !self.evaluate_some_prepare_command(tx, block, atom, &mut proposed_block_change_set)? {
                         return Ok(proposed_block_change_set.no_vote());
                     }
                 },
@@ -380,19 +391,14 @@ where TConsensusSpec: ConsensusSpec
                         block,
                         atom,
                         local_committee_info,
+                        &mut substate_store,
                         &mut proposed_block_change_set,
                     )? {
                         return Ok(proposed_block_change_set.no_vote());
                     }
                 },
                 Command::SomeAccept(atom) => {
-                    if !self.evaluate_some_accept_command(
-                        tx,
-                        block,
-                        atom,
-                        local_committee_info,
-                        &mut proposed_block_change_set,
-                    )? {
+                    if !self.evaluate_some_accept_command(tx, block, atom, &mut proposed_block_change_set)? {
                         return Ok(proposed_block_change_set.no_vote());
                     }
                 },
@@ -731,9 +737,6 @@ where TConsensusSpec: ConsensusSpec
             },
         }
 
-        // TODO: This QC is not necessarily evidence for this transaction, but typically for the parent block. We
-        //       could add transaction evidence once this block is justified.
-        tx_rec.add_qc_evidence(local_committee_info, *block.justify().id());
         proposed_block_change_set.set_next_transaction_update(&tx_rec, TransactionPoolStage::Prepared, true)?;
 
         Ok(true)
@@ -744,10 +747,9 @@ where TConsensusSpec: ConsensusSpec
         tx: &<TConsensusSpec::StateStore as StateStore>::ReadTransaction<'_>,
         block: &Block,
         atom: &TransactionAtom,
-        local_committee_info: &CommitteeInfo,
         proposed_block_change_set: &mut ProposedBlockChangeSet,
     ) -> Result<bool, HotStuffError> {
-        let Some(mut tx_rec) = self
+        let Some(tx_rec) = self
             .transaction_pool
             .get(tx, block.as_leaf_block(), atom.id())
             .optional()?
@@ -799,11 +801,10 @@ where TConsensusSpec: ConsensusSpec
             return Ok(false);
         }
 
-        tx_rec.add_qc_evidence(local_committee_info, *block.justify().id());
         proposed_block_change_set.set_next_transaction_update(
             &tx_rec,
             TransactionPoolStage::LocalPrepared,
-            tx_rec.evidence().all_addresses_justified(),
+            tx_rec.evidence().all_input_addresses_justified(),
         )?;
 
         Ok(true)
@@ -814,7 +815,6 @@ where TConsensusSpec: ConsensusSpec
         tx: &<TConsensusSpec::StateStore as StateStore>::ReadTransaction<'_>,
         block: &Block,
         atom: &TransactionAtom,
-        local_committee_info: &CommitteeInfo,
         proposed_block_change_set: &mut ProposedBlockChangeSet,
     ) -> Result<bool, HotStuffError> {
         if atom.decision.is_abort() {
@@ -826,7 +826,7 @@ where TConsensusSpec: ConsensusSpec
             return Ok(false);
         }
 
-        let Some(mut tx_rec) = self
+        let Some(tx_rec) = self
             .transaction_pool
             .get(tx, block.as_leaf_block(), atom.id())
             .optional()?
@@ -873,26 +873,22 @@ where TConsensusSpec: ConsensusSpec
             );
             return Ok(false);
         }
-
         // TODO: there is a race condition between the local node receiving the foreign LocalPrepare and the leader
-        // proposing AllPrepare. If the latter comes first, this node will not vote on this block which leads inevitably
-        // to erroneous leader failures. For this reason, this is commented out for now.
-        // if !tx_rec.evidence().all_addresses_justified() {
+        // proposing AllPrepare. If the latter comes first (because the leader received the foreign LocalPrepare),
+        // this node will not vote on this block which leads inevitably to erroneous leader failures. For this reason,
+        // this is commented out for now.
+
+        // if !tx_rec.evidence().all_input_addresses_justified() {
         //     warn!(
         //         target: LOG_TARGET,
-        //         "❌ AllPrepare disagreement for transaction {} in block {}. Leader proposed that all committees have
-        // justified, but local evidence is not all justified",         tx_rec.transaction_id(),
+        //         "❌ LocalPrepare disagreement for transaction {} in block {}. Leader proposed that all committees
+        // have justified, but local evidence is not all justified",         tx_rec.transaction_id(),
         //         block,
         //     );
         //     return Ok(false);
         // }
-
-        tx_rec.add_qc_evidence(local_committee_info, *block.justify().id());
-        proposed_block_change_set.set_next_transaction_update(
-            &tx_rec,
-            TransactionPoolStage::AllPrepared,
-            tx_rec.evidence().all_addresses_justified(),
-        )?;
+        //
+        proposed_block_change_set.set_next_transaction_update(&tx_rec, TransactionPoolStage::AllPrepared, true)?;
 
         Ok(true)
     }
@@ -902,7 +898,6 @@ where TConsensusSpec: ConsensusSpec
         tx: &<TConsensusSpec::StateStore as StateStore>::ReadTransaction<'_>,
         block: &Block,
         atom: &TransactionAtom,
-        local_committee_info: &CommitteeInfo,
         proposed_block_change_set: &mut ProposedBlockChangeSet,
     ) -> Result<bool, HotStuffError> {
         if atom.decision.is_commit() {
@@ -914,7 +909,7 @@ where TConsensusSpec: ConsensusSpec
             return Ok(false);
         }
 
-        let Some(mut tx_rec) = self
+        let Some(tx_rec) = self
             .transaction_pool
             .get(tx, block.as_leaf_block(), atom.id())
             .optional()?
@@ -962,7 +957,6 @@ where TConsensusSpec: ConsensusSpec
             return Ok(false);
         }
 
-        tx_rec.add_qc_evidence(local_committee_info, *block.justify().id());
         proposed_block_change_set.set_next_transaction_update(&tx_rec, TransactionPoolStage::SomePrepared, true)?;
 
         Ok(true)
@@ -1014,10 +1008,10 @@ where TConsensusSpec: ConsensusSpec
             tx_rec.update_from_execution(&execution);
 
             // Lock all local outputs
-            let local_outputs = execution
-                .resulting_outputs()
-                .iter()
-                .filter(|o| local_committee_info.includes_substate_address(&o.to_substate_address()));
+            let local_outputs = execution.resulting_outputs().iter().filter(|o| {
+                o.substate_id().is_transaction_receipt() ||
+                    local_committee_info.includes_substate_address(&o.to_substate_address())
+            });
             match substate_store.try_lock_all(*tx_rec.transaction_id(), local_outputs, false) {
                 Ok(()) => {},
                 Err(err) => {
@@ -1043,7 +1037,6 @@ where TConsensusSpec: ConsensusSpec
                         err
                     );
 
-                    tx_rec.add_qc_evidence(local_committee_info, *block.justify().id());
                     tx_rec.set_local_decision(Decision::Abort);
                     proposed_block_change_set
                         .set_next_transaction_update(
@@ -1091,31 +1084,9 @@ where TConsensusSpec: ConsensusSpec
 
         // maybe_execution is only None if the transaction is not committed
         if let Some(execution) = maybe_execution {
-            if tx_rec.current_decision().is_commit() {
-                let diff = execution.result().finalize.accept().ok_or_else(|| {
-                    HotStuffError::InvariantError(format!(
-                        "evaluate_local_accept_command: Transaction {} has COMMIT decision but execution failed when \
-                         proposing",
-                        tx_rec.transaction_id(),
-                    ))
-                })?;
-
-                substate_store.put_diff(*tx_rec.transaction_id(), diff)?;
-            }
             proposed_block_change_set.add_transaction_execution(execution)?;
         }
 
-        tx_rec.add_qc_evidence(local_committee_info, *block.justify().id());
-
-        // Good debug info
-        // tx_rec.evidence().iter().for_each(|(addr, ev)| {
-        //     let includes_local = local_committee_info.includes_substate_address(addr);
-        //     log::error!(
-        //         target: LOG_TARGET,
-        //         "🗾 VOTE ON LOCALACCEPT EVIDENCE (l={}, f={}) {}: {}", includes_local, !includes_local, addr, ev
-        //     );
-        // });
-
         proposed_block_change_set.set_next_transaction_update(
             &tx_rec,
             TransactionPoolStage::LocalAccepted,
@@ -1131,6 +1102,7 @@ where TConsensusSpec: ConsensusSpec
         block: &Block,
         atom: &TransactionAtom,
         local_committee_info: &CommitteeInfo,
+        substate_store: &mut PendingSubstateStore<TConsensusSpec::StateStore>,
         proposed_block_change_set: &mut ProposedBlockChangeSet,
     ) -> Result<bool, HotStuffError> {
         if atom.decision.is_abort() {
@@ -1142,7 +1114,7 @@ where TConsensusSpec: ConsensusSpec
             return Ok(false);
         }
 
-        let Some(mut tx_rec) = self
+        let Some(tx_rec) = self
             .transaction_pool
             .get(tx, block.as_leaf_block(), atom.id())
             .optional()?
@@ -1190,9 +1162,27 @@ where TConsensusSpec: ConsensusSpec
             return Ok(false);
         }
 
-        // TODO: This isn't the QC that justifies this, typically the block after this would (same applies to all other
-        // occurrences of this code)
-        tx_rec.add_qc_evidence(local_committee_info, *block.justify().id());
+        let execution = BlockTransactionExecution::get_pending_for_block(tx, tx_rec.transaction_id(), block.parent())
+            .optional()?
+            .ok_or_else(|| {
+                HotStuffError::InvariantError(format!(
+                    "evaluate_all_accept_command: Transaction {} has COMMIT decision but execution is missing",
+                    tx_rec.transaction_id()
+                ))
+            })?;
+
+        let diff = execution.result().finalize.accept().ok_or_else(|| {
+            HotStuffError::InvariantError(format!(
+                "evaluate_local_accept_command: Transaction {} has COMMIT decision but execution failed when proposing",
+                tx_rec.transaction_id(),
+            ))
+        })?;
+
+        substate_store.put_diff(
+            *tx_rec.transaction_id(),
+            &filter_diff_for_committee(local_committee_info, diff),
+        )?;
+
         proposed_block_change_set.set_next_transaction_update(&tx_rec, TransactionPoolStage::AllAccepted, false)?;
 
         Ok(true)
@@ -1203,7 +1193,6 @@ where TConsensusSpec: ConsensusSpec
         tx: &<TConsensusSpec::StateStore as StateStore>::ReadTransaction<'_>,
         block: &Block,
         atom: &TransactionAtom,
-        local_committee_info: &CommitteeInfo,
         proposed_block_change_set: &mut ProposedBlockChangeSet,
     ) -> Result<bool, HotStuffError> {
         if atom.decision.is_commit() {
@@ -1215,7 +1204,7 @@ where TConsensusSpec: ConsensusSpec
             return Ok(false);
         }
 
-        let Some(mut tx_rec) = self
+        let Some(tx_rec) = self
             .transaction_pool
             .get(tx, block.as_leaf_block(), atom.id())
             .optional()?
@@ -1290,7 +1279,6 @@ where TConsensusSpec: ConsensusSpec
             }
         }
 
-        tx_rec.add_qc_evidence(local_committee_info, *block.justify().id());
         proposed_block_change_set.set_next_transaction_update(&tx_rec, TransactionPoolStage::SomeAccepted, false)?;
 
         Ok(true)
diff --git a/dan_layer/consensus/src/hotstuff/on_receive_foreign_proposal.rs b/dan_layer/consensus/src/hotstuff/on_receive_foreign_proposal.rs
index 9e03e1fea0..d8c642381b 100644
--- a/dan_layer/consensus/src/hotstuff/on_receive_foreign_proposal.rs
+++ b/dan_layer/consensus/src/hotstuff/on_receive_foreign_proposal.rs
@@ -6,13 +6,16 @@ use tari_dan_common_types::{committee::CommitteeInfo, optional::Optional, ShardG
 use tari_dan_storage::{
     consensus_models::{
         Block,
+        BlockId,
         BlockPledge,
         Command,
         ForeignProposal,
         ForeignReceiveCounters,
         LeafBlock,
         QuorumCertificate,
+        TransactionAtom,
         TransactionPool,
+        TransactionPoolRecord,
         TransactionPoolStage,
     },
     StateStore,
@@ -52,6 +55,7 @@ where TConsensusSpec: ConsensusSpec
         }
     }
 
+    #[allow(clippy::too_many_lines)]
     pub async fn handle(
         &mut self,
         from: TConsensusSpec::Addr,
@@ -98,7 +102,7 @@ where TConsensusSpec: ConsensusSpec
             .commands()
             .iter()
             .filter_map(|command| {
-                if let Some(tx) = command.local_prepare() {
+                if let Some(tx) = command.local_prepare().or_else(|| command.local_accept()) {
                     if !foreign_committee_info.includes_any_address(command.evidence().substate_addresses_iter()) {
                         return None;
                     }
@@ -111,6 +115,17 @@ where TConsensusSpec: ConsensusSpec
             })
             .collect::<Vec<TransactionId>>();
 
+        // Justify QC must justify the block
+        if justify_qc.block_id() != block.id() {
+            warn!(
+                target: LOG_TARGET,
+                "⚠️ FOREIGN PROPOSAL: Justify QC block id does not match the block id. Justify QC block id: {}, block id: {}",
+                justify_qc.block_id(),
+                block.id(),
+            );
+            return Ok(());
+        }
+
         // The block height was validated earlier, so we can use the height only and not store the hash anymore
         let foreign_proposal = ForeignProposal::new(
             foreign_committee_info.shard_group(),
@@ -137,7 +152,7 @@ where TConsensusSpec: ConsensusSpec
             from,
         );
 
-        self.store.with_write_tx(|tx| {
+        let result = self.store.with_write_tx(|tx| {
             foreign_receive_counter.save(tx)?;
             foreign_proposal.upsert(tx)?;
             self.on_receive_foreign_block(
@@ -148,10 +163,23 @@ where TConsensusSpec: ConsensusSpec
                 local_committee_info,
                 block_pledge,
             )
-        })?;
-
-        // We could have ready transactions at this point, so if we're the leader for the next block we can propose
-        self.pacemaker.beat();
+        });
+
+        match result {
+            Ok(_) => {
+                // We could have ready transactions at this point, so if we're the leader for the next block we can
+                // propose
+                self.pacemaker.beat();
+            },
+            Err(err) => {
+                error!(
+                    target: LOG_TARGET,
+                    "⚠️ FOREIGN PROPOSAL: Failed to process foreign proposal for block {}: {}",
+                    block.id(),
+                    err
+                );
+            },
+        }
 
         Ok(())
     }
@@ -179,10 +207,10 @@ where TConsensusSpec: ConsensusSpec
                     }
 
                     let Some(mut tx_rec) = self.transaction_pool.get(tx, local_leaf, &atom.id).optional()? else {
-                        // TODO: request and sequence the transaction (elsewhere)
+                        // If this happens, it could be a bug in the foreign missing transaction handling
                         warn!(
                             target: LOG_TARGET,
-                            "⚠️ Foreign proposal received for transaction {} but this transaction is not in the pool.",
+                            "⚠️ NEVER HAPPEN: Foreign proposal received for transaction {} but this transaction is not in the pool.",
                             atom.id
                         );
                         continue;
@@ -218,60 +246,10 @@ where TConsensusSpec: ConsensusSpec
                         is_qc_saved = true;
                     }
 
-                    #[allow(clippy::mutable_key_type)]
-                    let maybe_pledges = if remote_decision.is_commit() {
-                        let pledges = block_pledge.remove_transaction_pledges(&atom.id).ok_or_else(|| {
-                            HotStuffError::ForeignNodeOmittedTransactionPledges {
-                                foreign_block_id: *block.id(),
-                                transaction_id: atom.id,
-                            }
-                        })?;
-
-                        // Validate that provided evidence is correct
-                        // TODO: there are a lot of validations to be done on evidence and the foreign block in general,
-                        // this is here as a sanity check and should change to not be a fatal error in consensus
-                        for pledge in &pledges {
-                            let address = pledge.versioned_substate_id().to_substate_address();
-                            let evidence = atom.evidence.get(&address).ok_or_else(|| {
-                                ProposalValidationError::ForeignInvalidPledge {
-                                    block_id: *block.id(),
-                                    transaction_id: atom.id,
-                                    details: format!("Pledge {pledge} for address {address} not found in evidence"),
-                                }
-                            })?;
-                            if evidence.lock.is_output() && pledge.is_input() {
-                                return Err(ProposalValidationError::ForeignInvalidPledge {
-                                    block_id: *block.id(),
-                                    transaction_id: atom.id,
-                                    details: format!(
-                                        "Pledge {pledge} is an input but evidence is an output for address {address}"
-                                    ),
-                                }
-                                .into());
-                            }
-                            if !evidence.lock.is_output() && pledge.is_output() {
-                                return Err(ProposalValidationError::ForeignInvalidPledge {
-                                    block_id: *block.id(),
-                                    transaction_id: atom.id,
-                                    details: format!(
-                                        "Pledge {pledge} is an output but evidence is an input for address {address}"
-                                    ),
-                                }
-                                .into());
-                            }
-                        }
-                        Some(pledges)
-                    } else {
-                        if block_pledge.remove_transaction_pledges(&atom.id).is_some() {
-                            return Err(ProposalValidationError::ForeignInvalidPledge {
-                                block_id: *block.id(),
-                                transaction_id: atom.id,
-                                details: "Remote decided ABORT but provided pledges".to_string(),
-                            }
-                            .into());
-                        }
-                        None
-                    };
+                    // We need to add the justify QC to the evidence because the all prepare block could not include it
+                    // yet
+                    let mut foreign_evidence = atom.evidence.clone();
+                    foreign_evidence.add_qc_evidence(foreign_committee_info, *justify_qc.id());
 
                     // Update the transaction record with any new information provided by this foreign block
                     tx_rec.update_remote_data(
@@ -279,14 +257,17 @@ where TConsensusSpec: ConsensusSpec
                         remote_decision,
                         *justify_qc.id(),
                         foreign_committee_info,
-                        atom.evidence.clone(),
+                        foreign_evidence,
                     )?;
 
-                    if let Some(pledges) = maybe_pledges {
-                        // If the foreign shard has committed the transaction, we can add the pledges to the transaction
-                        // record
-                        tx_rec.add_foreign_pledges(tx, foreign_committee_info.shard_group(), pledges)?;
-                    }
+                    self.validate_and_add_pledges(
+                        tx,
+                        &tx_rec,
+                        block.id(),
+                        atom,
+                        &mut block_pledge,
+                        foreign_committee_info,
+                    )?;
 
                     if tx_rec.current_stage().is_new() {
                         info!(
@@ -302,7 +283,8 @@ where TConsensusSpec: ConsensusSpec
                         // CASE: One foreign SG is involved in all inputs and executed the transaction, local SG is
                         // involved in the outputs
                         let transaction = tx_rec.get_transaction(&**tx)?;
-                        let is_ready = transaction.has_any_local_inputs(local_committee_info) ||
+                        let is_ready = local_committee_info.includes_substate_id(&transaction.to_receipt_id().into()) ||
+                            transaction.has_any_local_inputs(local_committee_info) ||
                             transaction.has_all_foreign_input_pledges(&**tx, local_committee_info)?;
 
                         if is_ready {
@@ -323,7 +305,8 @@ where TConsensusSpec: ConsensusSpec
                                 tx_rec.current_stage()
                             );
                         }
-                    } else if tx_rec.current_stage().is_local_prepared() && tx_rec.evidence().all_addresses_justified()
+                    } else if tx_rec.current_stage().is_local_prepared() &&
+                        tx_rec.evidence().all_input_addresses_justified()
                     {
                         // 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
@@ -345,7 +328,7 @@ where TConsensusSpec: ConsensusSpec
                         // need to handle this here. When we confirm foreign proposals correctly, we can remove this.
                     } else if tx_rec.current_stage().is_all_prepared() &&
                         !tx_rec.is_ready() &&
-                        tx_rec.evidence().all_addresses_justified()
+                        tx_rec.evidence().all_input_addresses_justified()
                     {
                         // If the transaction is AllPrepared, we're waiting for all foreign proposals. Propose
                         // transaction once we have them.
@@ -364,8 +347,9 @@ where TConsensusSpec: ConsensusSpec
                             tx_rec.transaction_id(),
                             tx_rec.current_decision(),
                             tx_rec.current_stage(),
-                             tx_rec.evidence().all_addresses_justified()
+                             tx_rec.evidence().all_input_addresses_justified()
                         );
+                        tx_rec.add_pending_status_update(tx, local_leaf, tx_rec.current_stage(), false)?;
                     }
                 },
                 Command::LocalAccept(atom) => {
@@ -373,11 +357,9 @@ where TConsensusSpec: ConsensusSpec
                         continue;
                     }
                     let Some(mut tx_rec) = self.transaction_pool.get(tx, local_leaf, &atom.id).optional()? else {
-                        // TODO: request and sequence the transaction (elsewhere)
-                        // This case will typically happen this shard group is only involved in outputs
                         warn!(
                             target: LOG_TARGET,
-                            "⚠️ Foreign proposal received for transaction {} but this transaction is not in the pool.",
+                            "⚠️ NEVER HAPPEN: Foreign proposal received for transaction {} but this transaction is not in the pool.",
                             atom.id
                         );
                         continue;
@@ -411,13 +393,27 @@ where TConsensusSpec: ConsensusSpec
                         is_qc_saved = true;
                     }
 
+                    // We need to add the justify QC to the evidence because the all prepare block could not include it
+                    // yet
+                    let mut foreign_evidence = atom.evidence.clone();
+                    foreign_evidence.add_qc_evidence(foreign_committee_info, *justify_qc.id());
+
                     // Update the transaction record with any new information provided by this foreign block
                     tx_rec.update_remote_data(
                         tx,
                         remote_decision,
                         *justify_qc.id(),
                         foreign_committee_info,
-                        atom.evidence.clone(),
+                        foreign_evidence,
+                    )?;
+
+                    self.validate_and_add_pledges(
+                        tx,
+                        &tx_rec,
+                        block.id(),
+                        atom,
+                        &mut block_pledge,
+                        foreign_committee_info,
                     )?;
 
                     // Good debug info
@@ -435,7 +431,8 @@ where TConsensusSpec: ConsensusSpec
                         // CASE: Foreign SGs have pledged all inputs and executed the transaction, local SG is involved
                         // in the outputs
                         let transaction = tx_rec.get_transaction(&**tx)?;
-                        let is_ready = transaction.has_any_local_inputs(local_committee_info) ||
+                        let is_ready = local_committee_info.includes_substate_id(&transaction.to_receipt_id().into()) ||
+                            transaction.has_any_local_inputs(local_committee_info) ||
                             transaction.has_all_foreign_input_pledges(&**tx, local_committee_info)?;
                         if is_ready {
                             info!(
@@ -475,6 +472,7 @@ where TConsensusSpec: ConsensusSpec
                             tx_rec.current_stage(),
                             tx_rec.evidence().all_addresses_justified()
                         );
+                        tx_rec.add_pending_status_update(tx, local_leaf, tx_rec.current_stage(), false)?;
                     }
                 },
                 // Should never receive this
@@ -517,6 +515,76 @@ where TConsensusSpec: ConsensusSpec
         Ok(())
     }
 
+    fn validate_and_add_pledges(
+        &self,
+        tx: &mut <TConsensusSpec::StateStore as StateStore>::WriteTransaction<'_>,
+        tx_rec: &TransactionPoolRecord,
+        block_id: &BlockId,
+        atom: &TransactionAtom,
+        block_pledge: &mut BlockPledge,
+        foreign_committee_info: &CommitteeInfo,
+    ) -> Result<(), HotStuffError> {
+        #[allow(clippy::mutable_key_type)]
+        let maybe_pledges = if atom.decision.is_commit() {
+            let pledges = block_pledge.remove_transaction_pledges(&atom.id).ok_or_else(|| {
+                HotStuffError::ForeignNodeOmittedTransactionPledges {
+                    foreign_block_id: *block_id,
+                    transaction_id: atom.id,
+                }
+            })?;
+
+            // Validate that provided evidence is correct
+            // TODO: there are a lot of validations to be done on evidence and the foreign block in general,
+            // this is here as a sanity check and should change to not be a fatal error in consensus
+            for pledge in &pledges {
+                let address = pledge.versioned_substate_id().to_substate_address();
+                let evidence =
+                    atom.evidence
+                        .get(&address)
+                        .ok_or_else(|| ProposalValidationError::ForeignInvalidPledge {
+                            block_id: *block_id,
+                            transaction_id: atom.id,
+                            details: format!("Pledge {pledge} for address {address} not found in evidence"),
+                        })?;
+                if evidence.lock.is_output() && pledge.is_input() {
+                    return Err(ProposalValidationError::ForeignInvalidPledge {
+                        block_id: *block_id,
+                        transaction_id: atom.id,
+                        details: format!("Pledge {pledge} is an input but evidence is an output for address {address}"),
+                    }
+                    .into());
+                }
+                if !evidence.lock.is_output() && pledge.is_output() {
+                    return Err(ProposalValidationError::ForeignInvalidPledge {
+                        block_id: *block_id,
+                        transaction_id: atom.id,
+                        details: format!("Pledge {pledge} is an output but evidence is an input for address {address}"),
+                    }
+                    .into());
+                }
+            }
+            Some(pledges)
+        } else {
+            if block_pledge.remove_transaction_pledges(&atom.id).is_some() {
+                return Err(ProposalValidationError::ForeignInvalidPledge {
+                    block_id: *block_id,
+                    transaction_id: atom.id,
+                    details: "Remote decided ABORT but provided pledges".to_string(),
+                }
+                .into());
+            }
+            None
+        };
+
+        if let Some(pledges) = maybe_pledges {
+            // If the foreign shard has committed the transaction, we can add the pledges to the transaction
+            // record
+            tx_rec.add_foreign_pledges(tx, foreign_committee_info.shard_group(), pledges)?;
+        }
+
+        Ok(())
+    }
+
     fn validate_proposed_block(
         &self,
         from: &TConsensusSpec::Addr,
diff --git a/dan_layer/consensus/src/hotstuff/on_receive_local_proposal.rs b/dan_layer/consensus/src/hotstuff/on_receive_local_proposal.rs
index 73c16242b7..e8019d60e7 100644
--- a/dan_layer/consensus/src/hotstuff/on_receive_local_proposal.rs
+++ b/dan_layer/consensus/src/hotstuff/on_receive_local_proposal.rs
@@ -156,7 +156,7 @@ impl<TConsensusSpec: ConsensusSpec> OnReceiveLocalProposalHandler<TConsensusSpec
             let (block_decision, valid_block) = task::spawn_blocking(move || {
                 let decision = on_ready_to_vote_on_local_block.handle(
                     &valid_block,
-                    local_committee_info,
+                    &local_committee_info,
                     can_propose_epoch_end,
                 )?;
                 Ok::<_, HotStuffError>((decision, valid_block))
@@ -287,11 +287,7 @@ impl<TConsensusSpec: ConsensusSpec> OnReceiveLocalProposalHandler<TConsensusSpec
     ) -> Result<(), HotStuffError> {
         for (block, justify_qc) in blocks {
             debug!(target:LOG_TARGET,"Broadcast new locked block: {block}");
-            let local_committee = self
-                .epoch_manager
-                .get_committee_by_validator_public_key(block.epoch(), block.proposed_by())
-                .await?;
-            let Some(our_addr) = self
+            let Some(our_vn) = self
                 .epoch_manager
                 .get_our_validator_node(block.epoch())
                 .await
@@ -299,24 +295,32 @@ impl<TConsensusSpec: ConsensusSpec> OnReceiveLocalProposalHandler<TConsensusSpec
             else {
                 info!(
                     target: LOG_TARGET,
-                    "❌ Our validator node is not registered for epoch {}. Not proposing {block} to foreign committee",
-                    block.epoch(),
+                    "❌ Our validator node is not registered for epoch {}. Not proposing {block} to foreign committee", block.epoch(),
                 );
                 continue;
             };
-            let leader_index = self.leader_strategy.calculate_leader(&local_committee, block.height());
+
+            let local_committee = self
+                .epoch_manager
+                .get_committee_by_validator_public_key(block.epoch(), block.proposed_by())
+                .await?;
+            let leader_index = self.leader_strategy.calculate_leader(&local_committee, block.height()) as usize;
             let my_index = local_committee
                 .addresses()
-                .position(|addr| *addr == our_addr.address)
+                .position(|addr| *addr == our_vn.address)
                 .ok_or_else(|| HotStuffError::InvariantError("Our address not found in local committee".to_string()))?;
-            // There are other ways to approach this. But for simplicty is better just to make sure at least one honest
-            // node will send it to the whole foreign committee. So we select the leader and f other nodes. It has to be
-            // deterministic so we select by index (leader, leader+1, ..., leader+f). FYI: The messages between
-            // committees and within committees are not different in terms of size, speed, etc.
-            let diff_from_leader = (my_index + local_committee.len() - leader_index as usize) % local_committee.len();
-            // f+1 nodes (always including the leader) send the proposal to the foreign committee
-            // if diff_from_leader <= (local_committee.len() - 1) / 3 + 1 {
-            if diff_from_leader <= local_committee.len() / 3 {
+            // There are other ways to approach this. But for simplicity, it is better just to make sure at least one
+            // honest node will send it to the whole foreign committee. So we select the leader and f other
+            // nodes. It has to be deterministic so we select by index (leader, leader+1, ..., leader+f).
+            // f+1 nodes (including the leader) send the proposal to the foreign committee
+
+            let should_broadcast = if my_index >= leader_index {
+                my_index - leader_index <= local_committee.len() / 3
+            } else {
+                my_index + local_committee.len() - leader_index <= local_committee.len() / 3
+            };
+
+            if should_broadcast {
                 self.broadcast_foreign_proposal_if_required(block, justify_qc).await?;
             }
         }
@@ -668,8 +672,9 @@ impl<TConsensusSpec: ConsensusSpec> OnReceiveLocalProposalHandler<TConsensusSpec
         }
         info!(
             target: LOG_TARGET,
-            "🌿 FOREIGN PROPOSE: Broadcasting locked block {} to {} foreign committees.",
+            "🌿 FOREIGN PROPOSE: Broadcasting locked block {} with {} pledge(s) to {} foreign committees.",
             block,
+            block_pledge.num_substates_pledged(),
             addresses.len(),
         );
         self.outbound_messaging
diff --git a/dan_layer/consensus/src/hotstuff/on_receive_new_transaction.rs b/dan_layer/consensus/src/hotstuff/on_receive_new_transaction.rs
index 51fc9f3a6c..70aadc3501 100644
--- a/dan_layer/consensus/src/hotstuff/on_receive_new_transaction.rs
+++ b/dan_layer/consensus/src/hotstuff/on_receive_new_transaction.rs
@@ -120,7 +120,9 @@ where TConsensusSpec: ConsensusSpec
 
         rec.save(tx)?;
 
-        let has_some_local_inputs_or_all_foreign_inputs = rec.has_any_local_inputs(local_committee_info) ||
+        let has_some_local_inputs_or_all_foreign_inputs = local_committee_info
+            .includes_substate_id(&rec.to_receipt_id().into()) ||
+            rec.has_any_local_inputs(local_committee_info) ||
             rec.has_all_foreign_input_pledges(&**tx, local_committee_info)?;
         self.add_to_pool(tx, &rec, has_some_local_inputs_or_all_foreign_inputs)?;
 
diff --git a/dan_layer/consensus/src/hotstuff/substate_store/error.rs b/dan_layer/consensus/src/hotstuff/substate_store/error.rs
index 5950f7b788..21d96a7621 100644
--- a/dan_layer/consensus/src/hotstuff/substate_store/error.rs
+++ b/dan_layer/consensus/src/hotstuff/substate_store/error.rs
@@ -1,14 +1,14 @@
 //   Copyright 2024 The Tari Project
 //   SPDX-License-Identifier: BSD-3-Clause
 
-use tari_dan_common_types::{optional::IsNotFoundError, SubstateAddress};
+use tari_dan_common_types::optional::IsNotFoundError;
 use tari_dan_storage::{consensus_models::SubstateLockType, StorageError};
 use tari_transaction::VersionedSubstateId;
 
 #[derive(Debug, thiserror::Error)]
 pub enum SubstateStoreError {
-    #[error("Substate {address} not found")]
-    SubstateNotFound { address: SubstateAddress },
+    #[error("Substate {id} not found")]
+    SubstateNotFound { id: VersionedSubstateId },
     #[error("Substate {id} is DOWN")]
     SubstateIsDown { id: VersionedSubstateId },
     #[error("Expected substate {id} to not exist but it was found")]
diff --git a/dan_layer/consensus/src/hotstuff/substate_store/pending_store.rs b/dan_layer/consensus/src/hotstuff/substate_store/pending_store.rs
index a28bc9c84f..bac0f68c14 100644
--- a/dan_layer/consensus/src/hotstuff/substate_store/pending_store.rs
+++ b/dan_layer/consensus/src/hotstuff/substate_store/pending_store.rs
@@ -77,9 +77,7 @@ impl<'a, 'tx, TStore: StateStore + 'a + 'tx> ReadableSubstateStore for PendingSu
         }
 
         let Some(substate) = SubstateRecord::get(self.read_transaction(), &id.to_substate_address()).optional()? else {
-            return Err(SubstateStoreError::SubstateNotFound {
-                address: id.to_substate_address(),
-            });
+            return Err(SubstateStoreError::SubstateNotFound { id: id.clone() });
         };
         Ok(substate.into_substate())
     }
@@ -206,6 +204,11 @@ impl<'a, 'tx, TStore: StateStore + 'a + 'tx> PendingSubstateStore<'a, 'tx, TStor
         let has_local_only_rules = existing.is_local_only() && is_local_only;
         let same_transaction = existing.transaction_id() == transaction_id;
 
+        // Duplicate lock requests on the same transaction are idempotent
+        if same_transaction {
+            return Ok(());
+        }
+
         match existing.substate_lock() {
             // If a substate is already locked as READ:
             // - it MAY be locked as READ
@@ -214,10 +217,10 @@ impl<'a, 'tx, TStore: StateStore + 'a + 'tx> PendingSubstateStore<'a, 'tx, TStor
             //   - it MAY be locked as requested.
             SubstateLockType::Read => {
                 // Cannot write to or create an output for a substate that is already read locked
-                if !same_transaction && !has_local_only_rules && !requested_lock_type.is_read() {
+                if !has_local_only_rules && !requested_lock_type.is_read() {
                     warn!(
                         target: LOG_TARGET,
-                        "⚠️ Lock conflict: [{}] Read lock(local={}) is present. Requested lock is {}(local={})",
+                        "⚠️ Lock conflict: [{}] Read lock(local_only={}) is present. Requested lock is {}(local_only={})",
                         requested_lock.versioned_substate_id(),
                         existing.is_local_only(),
                         requested_lock_type,
@@ -246,11 +249,11 @@ impl<'a, 'tx, TStore: StateStore + 'a + 'tx> PendingSubstateStore<'a, 'tx, TStor
             // - if Same-Transaction OR Local-Only-Rules:
             //   - it MAY be locked as OUTPUT
             SubstateLockType::Write => {
-                // Cannot lock a non-local WRITE locked substate
-                if !has_local_only_rules && !same_transaction {
+                // Cannot lock a non-local_only WRITE locked substate
+                if !has_local_only_rules {
                     warn!(
                         target: LOG_TARGET,
-                        "⚠️ Lock conflict: [{}] Write lock(local={}) is present. Requested lock is {}(local={})",
+                        "⚠️ Lock conflict: [{}] Write lock(local_only={}) is present. Requested lock is {}(local_only={})",
                         requested_lock.versioned_substate_id(),
                         existing.is_local_only(),
                         requested_lock_type,
@@ -266,7 +269,7 @@ impl<'a, 'tx, TStore: StateStore + 'a + 'tx> PendingSubstateStore<'a, 'tx, TStor
                 if !requested_lock_type.is_output() {
                     warn!(
                         target: LOG_TARGET,
-                        "⚠️ Lock conflict: [{}] Write lock(local={}) is present. Requested lock is {}(local={})",
+                        "⚠️ Lock conflict: [{}] Write lock(local_only={}) is present. Requested lock is {}(local_only={})",
                         requested_lock.versioned_substate_id(),
                         existing.is_local_only(),
                         requested_lock_type,
@@ -295,10 +298,11 @@ impl<'a, 'tx, TStore: StateStore + 'a + 'tx> PendingSubstateStore<'a, 'tx, TStor
             //   - it MAY be locked as WRITE or READ
             //   - it MUST NOT be locked as OUTPUT
             SubstateLockType::Output => {
-                if !same_transaction && !has_local_only_rules {
+                if !has_local_only_rules {
                     warn!(
                         target: LOG_TARGET,
-                        "⚠️ Lock conflict: [{}] Output lock(local={}) is present. Requested lock is {}(local={})",
+                        "⚠️ Lock conflict: [{}, {}] Output lock(local_only={}) is present. Requested lock is {}(local_only={})",
+                        transaction_id,
                         requested_lock.versioned_substate_id(),
                         existing.is_local_only(),
                         requested_lock_type,
@@ -314,7 +318,8 @@ impl<'a, 'tx, TStore: StateStore + 'a + 'tx> PendingSubstateStore<'a, 'tx, TStor
                 if requested_lock_type.is_output() {
                     warn!(
                         target: LOG_TARGET,
-                        "⚠️ Lock conflict: [{}] Output lock(local={}) is present. Requested lock is Output(local={})",
+                        "⚠️ Lock conflict: [{}, {}] Output lock(local_only={}) is present. Requested lock is Output(local_only={})",
+                        transaction_id,
                         requested_lock.versioned_substate_id(),
                         existing.is_local_only(),
                         is_local_only
@@ -389,9 +394,7 @@ impl<'a, 'tx, TStore: StateStore + 'a + 'tx> PendingSubstateStore<'a, 'tx, TStor
         match SubstateRecord::substate_is_up(self.read_transaction(), &id.to_substate_address()).optional()? {
             Some(true) => Ok(()),
             Some(false) => Err(SubstateStoreError::SubstateIsDown { id: id.clone() }),
-            None => Err(SubstateStoreError::SubstateNotFound {
-                address: id.to_substate_address(),
-            }),
+            None => Err(SubstateStoreError::SubstateNotFound { id: id.clone() }),
         }
     }
 
@@ -406,7 +409,7 @@ impl<'a, 'tx, TStore: StateStore + 'a + 'tx> PendingSubstateStore<'a, 'tx, TStor
         let address = id.to_substate_address();
         let Some(is_up) = SubstateRecord::substate_is_up(self.read_transaction(), &address).optional()? else {
             debug!(target: LOG_TARGET, "Expected substate {} to be DOWN but it does not exist", address);
-            return Err(SubstateStoreError::SubstateNotFound { address });
+            return Err(SubstateStoreError::SubstateNotFound { id: id.clone() });
         };
         if is_up {
             return Err(SubstateStoreError::ExpectedSubstateDown { id: id.clone() });
diff --git a/dan_layer/consensus/src/hotstuff/transaction_manager/manager.rs b/dan_layer/consensus/src/hotstuff/transaction_manager/manager.rs
index 6d9f1dfb3a..cdcb39933e 100644
--- a/dan_layer/consensus/src/hotstuff/transaction_manager/manager.rs
+++ b/dan_layer/consensus/src/hotstuff/transaction_manager/manager.rs
@@ -5,11 +5,7 @@ use std::{collections::HashSet, marker::PhantomData};
 
 use indexmap::IndexMap;
 use log::*;
-use tari_dan_common_types::{
-    committee::CommitteeInfo,
-    optional::{IsNotFoundError, Optional},
-    Epoch,
-};
+use tari_dan_common_types::{committee::CommitteeInfo, optional::IsNotFoundError, Epoch};
 use tari_dan_storage::{
     consensus_models::{
         Decision,
@@ -23,6 +19,7 @@ use tari_dan_storage::{
 use tari_engine_types::{
     commit_result::RejectReason,
     substate::{Substate, SubstateId},
+    transaction_receipt::TransactionReceiptAddress,
 };
 use tari_transaction::{SubstateRequirement, Transaction, TransactionId, VersionedSubstateId};
 
@@ -60,28 +57,20 @@ impl<TStateStore: StateStore, TExecutor: BlockTransactionExecutor<TStateStore>>
 
         let mut non_local_inputs = HashSet::new();
         for input in transaction.all_inputs_iter() {
+            if !local_committee_info.includes_substate_id(&input.substate_id) {
+                non_local_inputs.insert(input);
+                continue;
+            }
+
             match input.version() {
                 Some(version) => {
-                    if !local_committee_info.includes_substate_address(
-                        &input.to_substate_address().expect("succeeds because version is Some"),
-                    ) {
-                        non_local_inputs.insert(input);
-                        continue;
-                    }
-
                     let id = VersionedSubstateId::new(input.substate_id, version);
                     let substate = store.get(&id)?;
                     info!(target: LOG_TARGET, "Resolved LOCAL substate: {id}");
                     resolved_substates.insert(id.substate_id, substate);
                 },
                 None => {
-                    let substate = match store.get_latest(&input.substate_id).optional()? {
-                        Some(substate) => substate,
-                        None => {
-                            non_local_inputs.insert(input);
-                            continue;
-                        },
-                    };
+                    let substate = store.get_latest(&input.substate_id)?;
                     info!(target: LOG_TARGET, "Resolved LOCAL unversioned substate: {input}");
                     resolved_substates.insert(input.substate_id, substate);
                 },
@@ -128,6 +117,12 @@ impl<TStateStore: StateStore, TExecutor: BlockTransactionExecutor<TStateStore>>
         transaction_id: TransactionId,
     ) -> Result<PreparedTransaction, BlockTransactionExecutorError> {
         let mut transaction = TransactionRecord::get(store.read_transaction(), &transaction_id)?;
+        let mut outputs = HashSet::new();
+        outputs.insert(VersionedSubstateId::new(
+            TransactionReceiptAddress::from(transaction_id).into(),
+            0,
+        ));
+
         // Get the latest input substates
         let (local_inputs, non_local_inputs) = match self.resolve_local_substates(
             store,
@@ -160,7 +155,7 @@ impl<TStateStore: StateStore, TExecutor: BlockTransactionExecutor<TStateStore>>
                         transaction,
                         IndexMap::new(),
                         HashSet::new(),
-                        HashSet::new(),
+                        outputs,
                     ));
                 }
             },
@@ -216,7 +211,7 @@ impl<TStateStore: StateStore, TExecutor: BlockTransactionExecutor<TStateStore>>
             }
         } else {
             // CASE: Multishard transaction, not executed
-            PreparedTransaction::new_multishard(transaction, local_inputs, non_local_inputs, HashSet::new())
+            PreparedTransaction::new_multishard(transaction, local_inputs, non_local_inputs, outputs)
         };
 
         let lock_result = match &prepared {
@@ -233,21 +228,19 @@ impl<TStateStore: StateStore, TExecutor: BlockTransactionExecutor<TStateStore>>
                     // TODO: We do not know if the inputs locks required are Read/Write. Either we allow the user to
                     //       specify this or we can correct the locks after execution. Currently, this limitation
                     //       prevents concurrent multi-shard read locks.
-                    let requested_locks = multishard
-                        .local_inputs()
-                        .iter()
-                        .map(|(substate_id, substate)| {
-                            VersionedSubstateIdLockIntent::new(
-                                VersionedSubstateId::new(substate_id.clone(), substate.version()),
-                                SubstateLockType::Write,
-                            )
-                        })
+                    let requested_locks = multishard.local_inputs().iter().map(|(substate_id, substate)| {
+                        VersionedSubstateIdLockIntent::new(
+                            VersionedSubstateId::new(substate_id.clone(), substate.version()),
+                            SubstateLockType::Write,
+                        )
+                    })
                         // If outputs are known, lock all local outputs
                         .chain(
                             multishard
                                 .outputs()
                                 .iter()
-                                .filter(|o| local_committee_info.includes_substate_address(&o.to_substate_address()))
+                                .filter(|o| o.substate_id.is_transaction_receipt() ||
+                                    local_committee_info.includes_substate_address(&o.to_substate_address()))
                                 .map(|output| {
                                     VersionedSubstateIdLockIntent::new(output.clone(), SubstateLockType::Output)
                                 }),
diff --git a/dan_layer/consensus/src/hotstuff/transaction_manager/prepared.rs b/dan_layer/consensus/src/hotstuff/transaction_manager/prepared.rs
index 45ba1e3b73..871b2f1565 100644
--- a/dan_layer/consensus/src/hotstuff/transaction_manager/prepared.rs
+++ b/dan_layer/consensus/src/hotstuff/transaction_manager/prepared.rs
@@ -43,8 +43,8 @@ impl PreparedTransaction {
         Self::MultiShard(MultiShardPreparedTransaction {
             transaction,
             local_inputs,
-            outputs,
             foreign_inputs,
+            outputs,
         })
     }
 
@@ -134,7 +134,9 @@ impl MultiShardPreparedTransaction {
                     .all_inputs_iter()
                     .map(|input| input.or_zero_version())
                     .map(|id| VersionedSubstateIdLockIntent::new(id, SubstateLockType::Read)),
-                &[],
+                self.outputs
+                    .iter()
+                    .map(|id| VersionedSubstateIdLockIntent::new(id.clone(), SubstateLockType::Output)),
             );
         }
 
diff --git a/dan_layer/consensus/src/hotstuff/worker.rs b/dan_layer/consensus/src/hotstuff/worker.rs
index a4733ef2ac..b21a1a0abb 100644
--- a/dan_layer/consensus/src/hotstuff/worker.rs
+++ b/dan_layer/consensus/src/hotstuff/worker.rs
@@ -346,7 +346,7 @@ impl<TConsensusSpec: ConsensusSpec> HotstuffWorker<TConsensusSpec> {
 
         match self
             .on_message_validate
-            .handle(current_height, from.clone(), msg)
+            .handle(current_height, local_committee_info, from.clone(), msg)
             .await?
         {
             MessageValidationResult::Ready { from, message: msg } => {
@@ -368,17 +368,10 @@ impl<TConsensusSpec: ConsensusSpec> HotstuffWorker<TConsensusSpec> {
             } => {
                 let mut request_from_address = from;
                 if request_from_address == self.local_validator_addr {
-                    // let vn = self
-                    //     .epoch_manager
-                    //     .get_validator_node_by_public_key(epoch, &proposed_by)
-                    //     .await?;
-                    //
-                    // let mut request_from_address = vn.address;
-                    //
-                    // // (Yet another) Edge case: If we're catching up, we could be the proposer but we no longer have
-                    // the // transaction (we deleted our database) In this case, request from
-                    // another random VN // (TODO: not 100% reliable)
-                    // if request_from_address == self.local_validator_addr {
+                    // Edge case: If we're catching up, we could be the proposer but we no longer have
+                    // the transaction (we deleted our database likely during development testing).
+                    // In this case, request from another random VN.
+                    // (TODO: not 100% reliable since we're just asking a single random committee member)
                     let mut local_committee = self.epoch_manager.get_local_committee(epoch).await?;
 
                     local_committee.shuffle();
@@ -463,24 +456,56 @@ impl<TConsensusSpec: ConsensusSpec> HotstuffWorker<TConsensusSpec> {
         tx_id: &TransactionId,
         local_committee_info: &CommitteeInfo,
     ) -> Result<bool, HotStuffError> {
-        match self
+        let mut is_any_block_unparked = false;
+        if let Some(msg) = self
             .on_message_validate
-            .update_parked_blocks(current_height, tx_id)
-            .await?
+            .update_local_parked_blocks(current_height, tx_id)?
         {
-            Some((from, msg)) => {
-                if let Err(e) = self
-                    .dispatch_hotstuff_message(current_epoch, from, msg, local_committee_info)
-                    .await
-                {
-                    self.on_failure("on_new_transaction -> dispatch_hotstuff_message", &e)
-                        .await;
-                    return Err(e);
-                }
-                Ok(true)
-            },
-            None => Ok(false),
+            let vn = self
+                .epoch_manager
+                .get_validator_node_by_public_key(msg.block.epoch(), msg.block.proposed_by())
+                .await?;
+
+            if let Err(e) = self
+                .dispatch_hotstuff_message(
+                    current_epoch,
+                    vn.address,
+                    HotstuffMessage::Proposal(msg),
+                    local_committee_info,
+                )
+                .await
+            {
+                self.on_failure("on_new_transaction -> dispatch_hotstuff_message", &e)
+                    .await;
+                return Err(e);
+            }
+            is_any_block_unparked = true;
         }
+
+        let unparked_foreign_blocks = self.on_message_validate.update_foreign_parked_blocks(tx_id)?;
+        is_any_block_unparked |= !unparked_foreign_blocks.is_empty();
+        for parked in unparked_foreign_blocks {
+            let vn = self
+                .epoch_manager
+                .get_validator_node_by_public_key(parked.block().epoch(), parked.block().proposed_by())
+                .await?;
+
+            if let Err(e) = self
+                .dispatch_hotstuff_message(
+                    current_epoch,
+                    vn.address,
+                    HotstuffMessage::ForeignProposal(parked.into()),
+                    local_committee_info,
+                )
+                .await
+            {
+                self.on_failure("on_new_transaction -> dispatch_hotstuff_message", &e)
+                    .await;
+                return Err(e);
+            }
+        }
+
+        Ok(is_any_block_unparked)
     }
 
     async fn on_epoch_manager_event(&mut self, event: EpochManagerEvent) -> Result<(), HotStuffError> {
diff --git a/dan_layer/consensus/src/messages/proposal.rs b/dan_layer/consensus/src/messages/proposal.rs
index fe756103f8..b3f32d781b 100644
--- a/dan_layer/consensus/src/messages/proposal.rs
+++ b/dan_layer/consensus/src/messages/proposal.rs
@@ -4,7 +4,7 @@
 use std::fmt::{Display, Formatter};
 
 use serde::Serialize;
-use tari_dan_storage::consensus_models::{Block, BlockPledge, QuorumCertificate};
+use tari_dan_storage::consensus_models::{Block, BlockPledge, ForeignParkedProposal, QuorumCertificate};
 
 #[derive(Debug, Clone, Serialize)]
 pub struct ProposalMessage {
@@ -24,6 +24,22 @@ pub struct ForeignProposalMessage {
     pub block_pledge: BlockPledge,
 }
 
+impl From<ForeignProposalMessage> for ForeignParkedProposal {
+    fn from(msg: ForeignProposalMessage) -> Self {
+        ForeignParkedProposal::new(msg.block, msg.justify_qc, msg.block_pledge)
+    }
+}
+
+impl From<ForeignParkedProposal> for ForeignProposalMessage {
+    fn from(block: ForeignParkedProposal) -> Self {
+        ForeignProposalMessage {
+            block: block.block,
+            justify_qc: block.justify_qc,
+            block_pledge: block.block_pledge,
+        }
+    }
+}
+
 impl Display for ForeignProposalMessage {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         write!(
diff --git a/dan_layer/consensus_tests/src/consensus.rs b/dan_layer/consensus_tests/src/consensus.rs
index ba8efb026b..c8bb7799cb 100644
--- a/dan_layer/consensus_tests/src/consensus.rs
+++ b/dan_layer/consensus_tests/src/consensus.rs
@@ -180,17 +180,7 @@ async fn node_requests_missing_transaction_from_local_leader() {
             .send_transaction_to(&TestAddress::new("2"), Decision::Commit, 1, 5)
             .await;
         // All VNs will decide the same thing
-        test.create_execution_at_destination(
-            TestVnDestination::All,
-            create_execution_result_for_transaction(
-                BlockId::zero(),
-                *transaction.id(),
-                transaction.current_decision(),
-                0,
-                transaction.resolved_inputs.clone().unwrap_or_default(),
-                transaction.resulting_outputs.clone().unwrap_or_default(),
-            ),
-        );
+        test.create_execution_at_destination_for_transaction(TestVnDestination::All, &transaction);
     }
     test.start_epoch(Epoch(1)).await;
     loop {
@@ -397,7 +387,6 @@ async fn foreign_shard_decides_to_abort() {
 async fn multishard_local_inputs_foreign_outputs() {
     setup_logger();
     let mut test = Test::builder()
-        .with_test_timeout(Duration::from_secs(60))
         .add_committee(0, vec!["1", "2"])
         .add_committee(1, vec!["3", "4"])
         .start()
@@ -448,10 +437,10 @@ async fn multishard_local_inputs_foreign_outputs() {
 }
 
 #[tokio::test(flavor = "multi_thread", worker_threads = 4)]
-#[ignore = "TODO: this test does not work because more work is needed on multi-sharded output-only involvement"]
 async fn multishard_local_inputs_and_outputs_foreign_outputs() {
     setup_logger();
     let mut test = Test::builder()
+        .debug_sql("/tmp/test{}.db")
         .add_committee(0, vec!["1", "2"])
         .add_committee(1, vec!["3", "4"])
         .add_committee(2, vec!["5", "6"])
@@ -477,8 +466,13 @@ async fn multishard_local_inputs_and_outputs_foreign_outputs() {
             .collect(),
         outputs_0.into_iter().chain(outputs_2).collect(),
     );
-    test.send_transaction_to_destination(TestVnDestination::All, tx1.clone())
+    test.send_transaction_to_destination(TestVnDestination::Committee(0), tx1.clone())
+        .await;
+    test.send_transaction_to_destination(TestVnDestination::Committee(1), tx1.clone())
         .await;
+    // Just add the result for executing the transaction to committee 2, the transaction itself will be requested by
+    // consensus.
+    test.create_execution_at_destination_for_transaction(TestVnDestination::Committee(2), &tx1);
 
     test.start_epoch(Epoch(1)).await;
 
@@ -518,7 +512,14 @@ async fn multishard_output_conflict_abort() {
         .await;
 
     let tx1 = test.build_transaction(Decision::Commit, 1, 5, 2);
-    let resulting_outputs = tx1.resulting_outputs().unwrap().to_vec();
+    let resulting_outputs = tx1
+        .resulting_outputs()
+        .unwrap()
+        .iter()
+        // Dont use the transaction receipt as an output in tx2
+        .filter(|s| !s.substate_id().is_transaction_receipt())
+        .cloned()
+        .collect();
     test.send_transaction_to_destination(TestVnDestination::All, tx1.clone())
         .await;
 
@@ -722,10 +723,9 @@ async fn single_shard_input_conflict() {
         .build();
     let tx2 = TransactionRecord::new(tx2);
 
-    test.create_execution_at_destination(
+    test.add_execution_at_destination(
         TestVnDestination::All,
         create_execution_result_for_transaction(
-            BlockId::zero(),
             *tx1.id(),
             Decision::Commit,
             0,
@@ -733,10 +733,9 @@ async fn single_shard_input_conflict() {
             vec![],
         ),
     )
-    .create_execution_at_destination(
+    .add_execution_at_destination(
         TestVnDestination::All,
         create_execution_result_for_transaction(
-            BlockId::zero(),
             *tx2.id(),
             Decision::Commit,
             0,
@@ -961,10 +960,9 @@ async fn single_shard_unversioned_inputs() {
 
     test.send_transaction_to_destination(TestVnDestination::All, tx.clone())
         .await;
-    test.create_execution_at_destination(
+    test.add_execution_at_destination(
         TestVnDestination::All,
         create_execution_result_for_transaction(
-            BlockId::zero(),
             *tx.id(),
             Decision::Commit,
             0,
diff --git a/dan_layer/consensus_tests/src/substate_store.rs b/dan_layer/consensus_tests/src/substate_store.rs
index f48d275118..7b3e9710c8 100644
--- a/dan_layer/consensus_tests/src/substate_store.rs
+++ b/dan_layer/consensus_tests/src/substate_store.rs
@@ -157,7 +157,7 @@ fn it_disallows_more_than_one_write_lock_non_local_only() {
 }
 
 #[test]
-fn it_allows_locks_within_one_transaction() {
+fn it_allows_requesting_the_same_lock_within_one_transaction() {
     let store = create_store();
 
     let id = add_substate(&store, 0, 0);
@@ -192,7 +192,7 @@ fn it_allows_locks_within_one_transaction() {
         .unwrap();
 
     let n = store.new_locks().get(id.substate_id()).unwrap().len();
-    assert_eq!(n, 2);
+    assert_eq!(n, 1);
 }
 
 fn add_substate(store: &TestStore, seed: u8, version: u32) -> VersionedSubstateId {
diff --git a/dan_layer/consensus_tests/src/support/epoch_manager.rs b/dan_layer/consensus_tests/src/support/epoch_manager.rs
index 0a976b5eb2..a88ef3c1f8 100644
--- a/dan_layer/consensus_tests/src/support/epoch_manager.rs
+++ b/dan_layer/consensus_tests/src/support/epoch_manager.rs
@@ -7,7 +7,6 @@ use async_trait::async_trait;
 use tari_common_types::types::{FixedHash, PublicKey};
 use tari_dan_common_types::{
     committee::{Committee, CommitteeInfo},
-    shard::Shard,
     Epoch,
     ShardGroup,
     SubstateAddress,
@@ -249,14 +248,13 @@ impl EpochManagerReader for TestEpochManager {
         &self,
         _epoch: Epoch,
         shard_group: ShardGroup,
-    ) -> Result<HashMap<Shard, Committee<Self::Addr>>, EpochManagerError> {
+    ) -> Result<HashMap<ShardGroup, Committee<Self::Addr>>, EpochManagerError> {
         let state = self.state_lock().await;
-        Ok(state
-            .committees
-            .get(&shard_group)
-            .into_iter()
-            .flat_map(|committee| shard_group.shard_iter().map(|s| (s, committee.clone())))
-            .collect())
+        let Some(committee) = state.committees.get(&shard_group) else {
+            panic!("Committee not found for shard group {}", shard_group);
+        };
+
+        Ok(Some((shard_group, committee.clone())).into_iter().collect())
     }
 
     async fn get_committee_info_for_substate(
diff --git a/dan_layer/consensus_tests/src/support/executions_store.rs b/dan_layer/consensus_tests/src/support/executions_store.rs
index 6a58bdfffc..e7611c866a 100644
--- a/dan_layer/consensus_tests/src/support/executions_store.rs
+++ b/dan_layer/consensus_tests/src/support/executions_store.rs
@@ -6,10 +6,10 @@ use std::{
     sync::{Arc, RwLock},
 };
 
-use tari_dan_storage::consensus_models::BlockTransactionExecution;
+use tari_dan_storage::consensus_models::TransactionExecution;
 use tari_transaction::TransactionId;
 
-type TestExecutionStore = HashMap<TransactionId, BlockTransactionExecution>;
+type TestExecutionStore = HashMap<TransactionId, TransactionExecution>;
 
 #[derive(Debug, Clone, Default)]
 pub struct TestTransactionExecutionsStore {
@@ -23,15 +23,15 @@ impl TestTransactionExecutionsStore {
         }
     }
 
-    pub fn insert(&self, execution: BlockTransactionExecution) -> &Self {
+    pub fn insert(&self, execution: TransactionExecution) -> &Self {
         self.transactions
             .write()
             .unwrap()
-            .insert(*execution.transaction_id(), execution);
+            .insert(execution.transaction_id, execution);
         self
     }
 
-    pub fn get(&self, transaction_id: &TransactionId) -> Option<BlockTransactionExecution> {
+    pub fn get(&self, transaction_id: &TransactionId) -> Option<TransactionExecution> {
         self.transactions.read().unwrap().get(transaction_id).cloned()
     }
 }
diff --git a/dan_layer/consensus_tests/src/support/harness.rs b/dan_layer/consensus_tests/src/support/harness.rs
index b7e01957d5..0bea9f8a3c 100644
--- a/dan_layer/consensus_tests/src/support/harness.rs
+++ b/dan_layer/consensus_tests/src/support/harness.rs
@@ -13,11 +13,11 @@ use tari_dan_common_types::{committee::Committee, shard::Shard, Epoch, NodeHeigh
 use tari_dan_storage::{
     consensus_models::{
         BlockId,
-        BlockTransactionExecution,
         Decision,
         QcId,
         SubstateLockType,
         SubstateRecord,
+        TransactionExecution,
         TransactionRecord,
         VersionedSubstateIdLockIntent,
     },
@@ -107,32 +107,39 @@ impl Test {
         num_outputs: usize,
     ) -> TransactionRecord {
         let transaction = self.build_transaction(decision, fee, num_inputs, num_outputs);
-
         self.send_transaction_to_destination(TestVnDestination::All, transaction.clone())
             .await;
         transaction
     }
 
     pub async fn send_transaction_to_destination(&self, dest: TestVnDestination, transaction: TransactionRecord) {
-        self.create_execution_at_destination(
-            dest.clone(),
-            create_execution_result_for_transaction(
-                BlockId::zero(),
-                *transaction.id(),
-                transaction.current_decision(),
-                0,
-                transaction.resolved_inputs.clone().unwrap_or_default(),
-                transaction.resulting_outputs.clone().unwrap_or_default(),
-            ),
-        );
+        self.create_execution_at_destination_for_transaction(dest.clone(), &transaction);
         self.network.send_transaction(dest, transaction).await;
     }
 
-    pub fn create_execution_at_destination(
+    pub fn add_execution_at_destination(&self, dest: TestVnDestination, execution: TransactionExecution) -> &Self {
+        for vn in self.validators.values() {
+            if dest.is_for(&vn.address, vn.shard_group, vn.num_committees) {
+                vn.transaction_executions.insert(execution.clone());
+            }
+        }
+        self
+    }
+
+    pub fn create_execution_at_destination_for_transaction(
         &self,
         dest: TestVnDestination,
-        execution: BlockTransactionExecution,
+        transaction: &TransactionRecord,
     ) -> &Self {
+        let execution = transaction.clone().into_execution().unwrap_or_else(|| {
+            create_execution_result_for_transaction(
+                *transaction.id(),
+                transaction.current_decision(),
+                0,
+                transaction.resolved_inputs.clone().unwrap_or_default(),
+                transaction.resulting_outputs.clone().unwrap_or_default(),
+            )
+        });
         for vn in self.validators.values() {
             if dest.is_for(&vn.address, vn.shard_group, vn.num_committees) {
                 vn.transaction_executions.insert(execution.clone());
@@ -220,7 +227,7 @@ impl Test {
                         if v.shard_group
                             .contains(&substate.to_substate_address().to_shard(TEST_NUM_PRESHARDS))
                         {
-                            substate.clone().create(tx).unwrap();
+                            substate.create(tx).unwrap();
                         }
                     }
                     Ok::<_, StorageError>(())
diff --git a/dan_layer/consensus_tests/src/support/transaction.rs b/dan_layer/consensus_tests/src/support/transaction.rs
index c61babdf4b..e2bb7b045a 100644
--- a/dan_layer/consensus_tests/src/support/transaction.rs
+++ b/dan_layer/consensus_tests/src/support/transaction.rs
@@ -6,10 +6,10 @@ use std::{iter, time::Duration};
 use rand::{distributions::Alphanumeric, rngs::OsRng, Rng};
 use tari_common_types::types::PrivateKey;
 use tari_dan_storage::consensus_models::{
-    BlockId,
-    BlockTransactionExecution,
     Decision,
     ExecutedTransaction,
+    SubstateLockType,
+    TransactionExecution,
     TransactionRecord,
     VersionedSubstateIdLockIntent,
 };
@@ -17,7 +17,8 @@ use tari_engine_types::{
     commit_result::{ExecuteResult, FinalizeResult, RejectReason, TransactionResult},
     component::{ComponentBody, ComponentHeader},
     fees::FeeReceipt,
-    substate::{Substate, SubstateDiff},
+    substate::{Substate, SubstateDiff, SubstateId},
+    transaction_receipt::{TransactionReceipt, TransactionReceiptAddress},
 };
 use tari_transaction::{Transaction, TransactionId, VersionedSubstateId};
 
@@ -35,33 +36,34 @@ pub fn build_transaction_from(
         tx.set_abort_reason(RejectReason::ExecutionFailure("Test aborted".to_string()));
     }
 
-    let execution = create_execution_result_for_transaction(
-        // We're just building the execution here for DRY purposes, so genesis block id isn't used
-        BlockId::zero(),
-        *tx.id(),
-        decision,
-        fee,
-        resolved_inputs,
-        resulting_outputs.clone(),
-    );
+    let execution =
+        create_execution_result_for_transaction(*tx.id(), decision, fee, resolved_inputs, resulting_outputs.clone());
 
-    tx.execution_result = Some(execution.execution.result);
-    tx.resulting_outputs = Some(execution.execution.resulting_outputs);
-    tx.resolved_inputs = Some(execution.execution.resolved_inputs);
+    tx.execution_result = Some(execution.result);
+    tx.resulting_outputs = Some(execution.resulting_outputs);
+    tx.resolved_inputs = Some(execution.resolved_inputs);
     tx
 }
 
 pub fn create_execution_result_for_transaction(
-    block_id: BlockId,
     tx_id: TransactionId,
     decision: Decision,
     fee: u64,
     resolved_inputs: Vec<VersionedSubstateIdLockIntent>,
-    resulting_outputs: Vec<VersionedSubstateIdLockIntent>,
-) -> BlockTransactionExecution {
+    mut resulting_outputs: Vec<VersionedSubstateIdLockIntent>,
+) -> TransactionExecution {
     let result = if decision.is_commit() {
         let mut diff = SubstateDiff::new();
         for output in &resulting_outputs {
+            if output.substate_id().is_transaction_receipt() {
+                continue;
+            }
+            assert!(
+                output.substate_id().is_component(),
+                "create_execution_result_for_transaction: Test harness only supports generating component outputs. \
+                 Got {output}"
+            );
+
             let s = (0..100).map(|_| OsRng.sample(Alphanumeric) as char).collect::<String>();
             let random_state = tari_bor::to_value(&s).unwrap();
             diff.up(
@@ -82,6 +84,20 @@ pub fn create_execution_result_for_transaction(
                 }),
             )
         }
+        // We MUST create the transaction receipt
+        diff.up(
+            SubstateId::TransactionReceipt(TransactionReceiptAddress::from(tx_id)),
+            Substate::new(0, TransactionReceipt {
+                transaction_hash: tx_id.into_array().into(),
+                events: vec![],
+                logs: vec![],
+                fee_receipt: FeeReceipt {
+                    total_fee_payment: fee.try_into().unwrap(),
+                    total_fees_paid: fee.try_into().unwrap(),
+                    cost_breakdown: vec![],
+                },
+            }),
+        );
         TransactionResult::Accept(diff)
     } else {
         TransactionResult::Reject(RejectReason::ExecutionFailure(
@@ -89,8 +105,15 @@ pub fn create_execution_result_for_transaction(
         ))
     };
 
-    BlockTransactionExecution::new(
-        block_id,
+    resulting_outputs.push(VersionedSubstateIdLockIntent::new(
+        VersionedSubstateId::new(
+            SubstateId::TransactionReceipt(TransactionReceiptAddress::from(tx_id)),
+            0,
+        ),
+        SubstateLockType::Output,
+    ));
+
+    TransactionExecution::new(
         tx_id,
         ExecuteResult {
             finalize: FinalizeResult::new(tx_id.into_array().into(), vec![], vec![], result, FeeReceipt {
diff --git a/dan_layer/engine_types/src/substate.rs b/dan_layer/engine_types/src/substate.rs
index 814a04d525..6dc7327fca 100644
--- a/dan_layer/engine_types/src/substate.rs
+++ b/dan_layer/engine_types/src/substate.rs
@@ -609,6 +609,12 @@ impl From<FeeClaim> for SubstateValue {
     }
 }
 
+impl From<TransactionReceipt> for SubstateValue {
+    fn from(tx_receipt: TransactionReceipt) -> Self {
+        Self::TransactionReceipt(tx_receipt)
+    }
+}
+
 impl Display for SubstateValue {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         // TODO: improve output
@@ -644,10 +650,20 @@ impl SubstateDiff {
         self.up_substates.push((address, value));
     }
 
+    pub fn extend_up(&mut self, iter: impl Iterator<Item = (SubstateId, Substate)>) -> &mut Self {
+        self.up_substates.extend(iter);
+        self
+    }
+
     pub fn down(&mut self, address: SubstateId, version: u32) {
         self.down_substates.push((address, version));
     }
 
+    pub fn extend_down(&mut self, iter: impl Iterator<Item = (SubstateId, u32)>) -> &mut Self {
+        self.down_substates.extend(iter);
+        self
+    }
+
     pub fn up_iter(&self) -> impl Iterator<Item = &(SubstateId, Substate)> + '_ {
         self.up_substates.iter()
     }
diff --git a/dan_layer/epoch_manager/src/base_layer/base_layer_epoch_manager.rs b/dan_layer/epoch_manager/src/base_layer/base_layer_epoch_manager.rs
index 5162799f17..961917fcee 100644
--- a/dan_layer/epoch_manager/src/base_layer/base_layer_epoch_manager.rs
+++ b/dan_layer/epoch_manager/src/base_layer/base_layer_epoch_manager.rs
@@ -29,7 +29,6 @@ use tari_core::{blocks::BlockHeader, transactions::transaction_components::Valid
 use tari_dan_common_types::{
     committee::{Committee, CommitteeInfo},
     optional::Optional,
-    shard::Shard,
     DerivableFromPublicKey,
     Epoch,
     NodeAddressable,
@@ -613,7 +612,7 @@ impl<TAddr: NodeAddressable + DerivableFromPublicKey>
         &self,
         epoch: Epoch,
         shard_group: ShardGroup,
-    ) -> Result<HashMap<Shard, Committee<TAddr>>, EpochManagerError> {
+    ) -> Result<HashMap<ShardGroup, Committee<TAddr>>, EpochManagerError> {
         let mut tx = self.global_db.create_transaction()?;
         let mut validator_node_db = self.global_db.validator_nodes(&mut tx);
         let committees = validator_node_db.get_committees_for_shard_group(epoch, shard_group)?;
diff --git a/dan_layer/epoch_manager/src/base_layer/handle.rs b/dan_layer/epoch_manager/src/base_layer/handle.rs
index 581c682220..6f3f2dbc19 100644
--- a/dan_layer/epoch_manager/src/base_layer/handle.rs
+++ b/dan_layer/epoch_manager/src/base_layer/handle.rs
@@ -9,7 +9,6 @@ use tari_common_types::types::{FixedHash, PublicKey};
 use tari_core::transactions::{tari_amount::MicroMinotari, transaction_components::ValidatorNodeRegistration};
 use tari_dan_common_types::{
     committee::{Committee, CommitteeInfo},
-    shard::Shard,
     Epoch,
     NodeAddressable,
     ShardGroup,
@@ -408,7 +407,7 @@ impl<TAddr: NodeAddressable> EpochManagerReader for EpochManagerHandle<TAddr> {
         &self,
         epoch: Epoch,
         shard_group: ShardGroup,
-    ) -> Result<HashMap<Shard, Committee<Self::Addr>>, EpochManagerError> {
+    ) -> Result<HashMap<ShardGroup, Committee<Self::Addr>>, EpochManagerError> {
         let (tx, rx) = oneshot::channel();
         self.tx_request
             .send(EpochManagerRequest::GetCommitteesForShardGroup {
diff --git a/dan_layer/epoch_manager/src/base_layer/types.rs b/dan_layer/epoch_manager/src/base_layer/types.rs
index 7599914d8b..b11ef3c3a6 100644
--- a/dan_layer/epoch_manager/src/base_layer/types.rs
+++ b/dan_layer/epoch_manager/src/base_layer/types.rs
@@ -8,7 +8,6 @@ use tari_common_types::types::{FixedHash, PublicKey};
 use tari_core::transactions::{tari_amount::MicroMinotari, transaction_components::ValidatorNodeRegistration};
 use tari_dan_common_types::{
     committee::{Committee, CommitteeInfo},
-    shard::Shard,
     Epoch,
     ShardGroup,
     SubstateAddress,
@@ -129,7 +128,7 @@ pub enum EpochManagerRequest<TAddr> {
     GetCommitteesForShardGroup {
         epoch: Epoch,
         shard_group: ShardGroup,
-        reply: Reply<HashMap<Shard, Committee<TAddr>>>,
+        reply: Reply<HashMap<ShardGroup, Committee<TAddr>>>,
     },
     GetBaseLayerBlockHeight {
         hash: FixedHash,
diff --git a/dan_layer/epoch_manager/src/traits.rs b/dan_layer/epoch_manager/src/traits.rs
index ef1c030f88..03134306c2 100644
--- a/dan_layer/epoch_manager/src/traits.rs
+++ b/dan_layer/epoch_manager/src/traits.rs
@@ -26,7 +26,6 @@ use async_trait::async_trait;
 use tari_common_types::types::{FixedHash, PublicKey};
 use tari_dan_common_types::{
     committee::{Committee, CommitteeInfo},
-    shard::Shard,
     Epoch,
     NodeAddressable,
     ShardGroup,
@@ -118,7 +117,7 @@ pub trait EpochManagerReader: Send + Sync {
         &self,
         epoch: Epoch,
         shards: ShardGroup,
-    ) -> Result<HashMap<Shard, Committee<Self::Addr>>, EpochManagerError>;
+    ) -> Result<HashMap<ShardGroup, Committee<Self::Addr>>, EpochManagerError>;
 
     async fn get_local_committee(&self, epoch: Epoch) -> Result<Committee<Self::Addr>, EpochManagerError> {
         let validator = self.get_our_validator_node(epoch).await?;
diff --git a/dan_layer/rpc_state_sync/src/manager.rs b/dan_layer/rpc_state_sync/src/manager.rs
index 5cf927027e..b7611788d5 100644
--- a/dan_layer/rpc_state_sync/src/manager.rs
+++ b/dan_layer/rpc_state_sync/src/manager.rs
@@ -11,7 +11,15 @@ use tari_consensus::{
     hotstuff::substate_store::{ShardScopedTreeStoreReader, ShardScopedTreeStoreWriter},
     traits::{ConsensusSpec, SyncManager, SyncStatus},
 };
-use tari_dan_common_types::{committee::Committee, optional::Optional, shard::Shard, Epoch, NodeHeight, PeerAddress};
+use tari_dan_common_types::{
+    committee::Committee,
+    optional::Optional,
+    shard::Shard,
+    Epoch,
+    NodeHeight,
+    PeerAddress,
+    ShardGroup,
+};
 use tari_dan_p2p::proto::rpc::{GetCheckpointRequest, GetCheckpointResponse, SyncStateRequest};
 use tari_dan_storage::{
     consensus_models::{
@@ -320,7 +328,7 @@ where TConsensusSpec: ConsensusSpec<Addr = PeerAddress>
     async fn get_sync_committees(
         &self,
         current_epoch: Epoch,
-    ) -> Result<Vec<(Shard, Committee<PeerAddress>)>, CommsRpcConsensusSyncError> {
+    ) -> Result<Vec<(ShardGroup, Committee<PeerAddress>)>, CommsRpcConsensusSyncError> {
         // We are behind at least one epoch.
         // We get the current substate range, and we asks committees from previous epoch in this range to give us
         // data.
@@ -395,96 +403,98 @@ where TConsensusSpec: ConsensusSpec<Addr = PeerAddress> + Send + Sync + 'static
         let mut last_error = None;
         // Sync data from each committee in range of the committee we're joining.
         // NOTE: we don't have to worry about substates in address range because shard boundaries are fixed.
-        for (shard, mut committee) in prev_epoch_committees {
-            info!(target: LOG_TARGET, "🛜Syncing state for {shard} and {}", current_epoch.saturating_sub(Epoch(1)));
-            let mut remaining_members = committee.len();
+        for (shard_group, mut committee) in prev_epoch_committees {
             committee.shuffle();
-            for (addr, public_key) in committee {
-                remaining_members = remaining_members.saturating_sub(1);
-                if our_vn.public_key == public_key {
-                    continue;
-                }
-                let mut client = match self.establish_rpc_session(&addr).await {
-                    Ok(c) => c,
-                    Err(err) => {
-                        warn!(
-                            target: LOG_TARGET,
-                            "Failed to establish RPC session with vn {addr}: {err}. Attempting another VN if available"
-                        );
-                        if remaining_members == 0 {
-                            return Err(err);
-                        }
-                        last_error = Some(err);
+            for shard in shard_group.shard_iter() {
+                let mut remaining_members = committee.len();
+                info!(target: LOG_TARGET, "🛜Syncing state for {shard} and {}", current_epoch.saturating_sub(Epoch(1)));
+                for (addr, public_key) in &committee {
+                    remaining_members = remaining_members.saturating_sub(1);
+                    if our_vn.public_key == *public_key {
                         continue;
-                    },
-                };
-
-                let checkpoint = match self.fetch_epoch_checkpoint(&mut client, current_epoch).await {
-                    Ok(Some(cp)) => cp,
-                    Ok(None) => {
-                        // EDGE-CASE: This may occur because the previous epoch had not started consensus, typically in
-                        // testing cases where transactions
-                        warn!(
-                            target: LOG_TARGET,
-                            "❓No checkpoint for epoch {current_epoch}. This may mean that this is the first epoch in the network"
-                        );
-                        return Ok(());
-                    },
-                    Err(err) => {
-                        warn!(
-                            target: LOG_TARGET,
-                            "⚠️Failed to fetch checkpoint from {addr}: {err}. Attempting another peer if available"
-                        );
-                        if remaining_members == 0 {
-                            return Err(err);
-                        }
-                        last_error = Some(err);
-                        continue;
-                    },
-                };
-                info!(target: LOG_TARGET, "🛜 Checkpoint: {checkpoint}");
-
-                self.validate_checkpoint(&checkpoint)?;
-
-                match self.start_state_sync(&mut client, shard, &checkpoint).await {
-                    Ok(current_version) => {
-                        let state_root = self.get_state_root_for_shard(shard, current_version)?;
+                    }
+                    let mut client = match self.establish_rpc_session(addr).await {
+                        Ok(c) => c,
+                        Err(err) => {
+                            warn!(
+                                target: LOG_TARGET,
+                                "Failed to establish RPC session with vn {addr}: {err}. Attempting another VN if available"
+                            );
+                            if remaining_members == 0 {
+                                return Err(err);
+                            }
+                            last_error = Some(err);
+                            continue;
+                        },
+                    };
 
-                        if state_root != checkpoint.get_shard_root(shard) {
-                            error!(
+                    let checkpoint = match self.fetch_epoch_checkpoint(&mut client, current_epoch).await {
+                        Ok(Some(cp)) => cp,
+                        Ok(None) => {
+                            // EDGE-CASE: This may occur because the previous epoch had not started consensus, typically
+                            // in testing cases where transactions
+                            warn!(
                                 target: LOG_TARGET,
-                                "❌State root mismatch for {shard}. Expected {expected} but got {actual}",
-                                expected = checkpoint.get_shard_root(shard),
-                                actual = state_root,
+                                "❓No checkpoint for epoch {current_epoch}. This may mean that this is the first epoch in the network"
+                            );
+                            return Ok(());
+                        },
+                        Err(err) => {
+                            warn!(
+                                target: LOG_TARGET,
+                                "⚠️Failed to fetch checkpoint from {addr}: {err}. Attempting another peer if available"
                             );
-                            last_error = Some(CommsRpcConsensusSyncError::StateRootMismatch {
-                                expected: *checkpoint.block().merkle_root(),
-                                actual: state_root,
-                            });
-                            // TODO: rollback state
                             if remaining_members == 0 {
-                                return Err(last_error.unwrap());
+                                return Err(err);
                             }
+                            last_error = Some(err);
+                            continue;
+                        },
+                    };
+                    info!(target: LOG_TARGET, "🛜 Checkpoint: {checkpoint}");
+
+                    self.validate_checkpoint(&checkpoint)?;
+
+                    match self.start_state_sync(&mut client, shard, &checkpoint).await {
+                        Ok(current_version) => {
+                            let state_root = self.get_state_root_for_shard(shard, current_version)?;
+
+                            if state_root != checkpoint.get_shard_root(shard) {
+                                error!(
+                                    target: LOG_TARGET,
+                                    "❌State root mismatch for {shard}. Expected {expected} but got {actual}",
+                                    expected = checkpoint.get_shard_root(shard),
+                                    actual = state_root,
+                                );
+                                last_error = Some(CommsRpcConsensusSyncError::StateRootMismatch {
+                                    expected: *checkpoint.block().merkle_root(),
+                                    actual: state_root,
+                                });
+                                // TODO: rollback state
+                                if remaining_members == 0 {
+                                    return Err(last_error.unwrap());
+                                }
+
+                                continue;
+                            }
+
+                            info!(target: LOG_TARGET, "🛜Synced state for {shard} to v{} with root {state_root}", current_version.unwrap_or(0));
+                        },
+                        Err(err) => {
+                            warn!(
+                                target: LOG_TARGET,
+                                "⚠️Failed to sync state from {addr}: {err}. Attempting another peer if available"
+                            );
 
+                            if remaining_members == 0 {
+                                return Err(err);
+                            }
+                            last_error = Some(err);
                             continue;
-                        }
-
-                        info!(target: LOG_TARGET, "🛜Synced state for {shard} to v{} with root {state_root}", current_version.unwrap_or(0));
-                    },
-                    Err(err) => {
-                        warn!(
-                            target: LOG_TARGET,
-                            "⚠️Failed to sync state from {addr}: {err}. Attempting another peer if available"
-                        );
-
-                        if remaining_members == 0 {
-                            return Err(err);
-                        }
-                        last_error = Some(err);
-                        continue;
-                    },
+                        },
+                    }
+                    break;
                 }
-                break;
             }
         }
 
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 9c8358f05f..d42e2ef642 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
@@ -68,6 +68,39 @@ create table parked_blocks
 -- block_id must be unique. Optimise fetching by block_id
 create unique index parked_blocks_uniq_idx_id on parked_blocks (block_id);
 
+CREATE TABLE missing_transactions
+(
+    id                    integer   not NULL primary key AUTOINCREMENT,
+    block_id              text      not NULL,
+    block_height          bigint    not NULL,
+    transaction_id        text      not NULL,
+    is_awaiting_execution boolean   not NULL,
+    created_at            timestamp not NULL DEFAULT CURRENT_TIMESTAMP,
+    FOREIGN KEY (block_id) REFERENCES parked_blocks (block_id)
+);
+
+create table foreign_parked_blocks
+(
+    id                      integer   not null primary key AUTOINCREMENT,
+    block_id                text      not NULL,
+    block                   text      not NULL,
+    block_pledges           text      not NULL,
+    justify_qc              text      not NULL,
+    created_at              timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP
+);
+
+-- block_id must be unique. Optimise fetching by block_id
+create unique index foreign_parked_blocks_uniq_idx_id on parked_blocks (block_id);
+
+CREATE TABLE foreign_missing_transactions
+(
+    id                    integer   not NULL primary key AUTOINCREMENT,
+    parked_block_id       integer   not NULL,
+    transaction_id        text      not NULL,
+    created_at            timestamp not NULL DEFAULT CURRENT_TIMESTAMP,
+    FOREIGN KEY (parked_block_id) REFERENCES foreign_parked_blocks (id)
+);
+
 create table leaf_blocks
 (
     id           integer   not null primary key AUTOINCREMENT,
@@ -144,6 +177,7 @@ create table foreign_substate_pledges
 );
 
 create index foreign_substate_pledges_transaction_id_idx on foreign_substate_pledges (transaction_id);
+create unique index foreign_substate_pledges_transaction_id_substate_id_uniq_idx on foreign_substate_pledges (transaction_id, substate_id);
 
 create table substate_locks
 (
@@ -313,18 +347,6 @@ create table votes
     created_at       timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP
 );
 
-
-CREATE TABLE missing_transactions
-(
-    id                    integer   not NULL primary key AUTOINCREMENT,
-    block_id              text      not NULL,
-    block_height          bigint    not NULL,
-    transaction_id        text      not NULL,
-    is_awaiting_execution boolean   not NULL,
-    created_at            timestamp not NULL DEFAULT CURRENT_TIMESTAMP,
-    FOREIGN KEY (block_id) REFERENCES parked_blocks (block_id)
-);
-
 CREATE TABLE foreign_proposals
 (
     id                      integer   not NULL primary key AUTOINCREMENT,
@@ -394,7 +416,6 @@ CREATE TABLE pending_state_tree_diffs
 
 CREATE UNIQUE INDEX pending_state_tree_diffs_uniq_idx_block_id_shard on pending_state_tree_diffs (block_id, shard);
 
-
 CREATE TABLE epoch_checkpoints
 (
     id              integer   not NULL primary key AUTOINCREMENT,
diff --git a/dan_layer/state_store_sqlite/src/reader.rs b/dan_layer/state_store_sqlite/src/reader.rs
index fafa61375c..d92afd7b98 100644
--- a/dan_layer/state_store_sqlite/src/reader.rs
+++ b/dan_layer/state_store_sqlite/src/reader.rs
@@ -1384,6 +1384,7 @@ impl<'tx, TAddr: NodeAddressable + Serialize + DeserializeOwned + 'tx> StateStor
         use crate::schema::transaction_pool;
 
         let ready_txs = transaction_pool::table
+            // Important: Order by transaction_id to ensure deterministic ordering
             .order_by(transaction_pool::transaction_id.asc())
             .get_results::<sql_models::TransactionPoolRecord>(self.connection())
             .map_err(|e| SqliteStorageError::DieselError {
diff --git a/dan_layer/state_store_sqlite/src/schema.rs b/dan_layer/state_store_sqlite/src/schema.rs
index ad95259a70..087837abbc 100644
--- a/dan_layer/state_store_sqlite/src/schema.rs
+++ b/dan_layer/state_store_sqlite/src/schema.rs
@@ -53,6 +53,26 @@ diesel::table! {
     }
 }
 
+diesel::table! {
+    foreign_missing_transactions (id) {
+        id -> Integer,
+        parked_block_id -> Integer,
+        transaction_id -> Text,
+        created_at -> Timestamp,
+    }
+}
+
+diesel::table! {
+    foreign_parked_blocks (id) {
+        id -> Integer,
+        block_id -> Text,
+        block -> Text,
+        block_pledges -> Text,
+        justify_qc -> Text,
+        created_at -> Timestamp,
+    }
+}
+
 diesel::table! {
     foreign_proposals (id) {
         id -> Integer,
@@ -408,10 +428,14 @@ diesel::table! {
     }
 }
 
+diesel::joinable!(foreign_missing_transactions -> foreign_parked_blocks (parked_block_id));
+
 diesel::allow_tables_to_appear_in_same_query!(
     block_diffs,
     blocks,
     epoch_checkpoints,
+    foreign_missing_transactions,
+    foreign_parked_blocks,
     foreign_proposals,
     foreign_receive_counters,
     foreign_send_counters,
diff --git a/dan_layer/state_store_sqlite/src/sql_models/foreign_parked_block.rs b/dan_layer/state_store_sqlite/src/sql_models/foreign_parked_block.rs
new file mode 100644
index 0000000000..a7643f6127
--- /dev/null
+++ b/dan_layer/state_store_sqlite/src/sql_models/foreign_parked_block.rs
@@ -0,0 +1,34 @@
+//   Copyright 2024 The Tari Project
+//   SPDX-License-Identifier: BSD-3-Clause
+
+use diesel::Queryable;
+use tari_dan_storage::{consensus_models, StorageError};
+use time::PrimitiveDateTime;
+
+use crate::serialization::deserialize_json;
+
+#[derive(Debug, Clone, Queryable)]
+pub struct ForeignParkedBlock {
+    pub id: i32,
+    pub block_id: String,
+    pub block: String,
+    pub block_pledges: String,
+    pub justify_qc: String,
+    pub created_at: PrimitiveDateTime,
+}
+
+impl TryFrom<ForeignParkedBlock> for consensus_models::ForeignParkedProposal {
+    type Error = StorageError;
+
+    fn try_from(value: ForeignParkedBlock) -> Result<Self, Self::Error> {
+        let block = deserialize_json(&value.block)?;
+        let block_pledge = deserialize_json(&value.block_pledges)?;
+        let justify_qc = deserialize_json(&value.justify_qc)?;
+
+        Ok(consensus_models::ForeignParkedProposal::new(
+            block,
+            justify_qc,
+            block_pledge,
+        ))
+    }
+}
diff --git a/dan_layer/state_store_sqlite/src/sql_models/mod.rs b/dan_layer/state_store_sqlite/src/sql_models/mod.rs
index b91b44b682..7c232f530f 100644
--- a/dan_layer/state_store_sqlite/src/sql_models/mod.rs
+++ b/dan_layer/state_store_sqlite/src/sql_models/mod.rs
@@ -5,6 +5,7 @@ mod block;
 mod block_diff;
 mod bookkeeping;
 mod epoch_checkpoint;
+mod foreign_parked_block;
 mod foreign_substate_pledge;
 mod leaf_block;
 mod pending_state_tree_diff;
@@ -21,6 +22,7 @@ pub use block::*;
 pub use block_diff::*;
 pub use bookkeeping::*;
 pub use epoch_checkpoint::*;
+pub use foreign_parked_block::*;
 pub use foreign_substate_pledge::*;
 pub use leaf_block::*;
 pub use pending_state_tree_diff::*;
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 472d4e2308..56ec782b22 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
@@ -49,14 +49,19 @@ impl TransactionPoolRecord {
         let mut local_decision = self.local_decision;
         let mut is_ready = self.is_ready;
         if let Some(update) = update {
-            evidence.merge(deserialize_json::<Evidence>(&update.evidence)?);
+            evidence.merge(deserialize_json(&update.evidence)?);
             is_ready = update.is_ready;
             pending_stage = Some(parse_from_string(&update.stage)?);
             local_decision = update.local_decision;
         }
 
-        if let Some(ref remote_evidence) = self.remote_evidence {
-            evidence.merge(deserialize_json::<Evidence>(remote_evidence)?);
+        let remote_evidence = self
+            .remote_evidence
+            .as_deref()
+            .map(deserialize_json::<Evidence>)
+            .transpose()?;
+        if let Some(ref remote_evidence) = remote_evidence {
+            evidence.merge(remote_evidence.clone());
         }
 
         let leader_fee = self
@@ -81,6 +86,7 @@ impl TransactionPoolRecord {
         Ok(consensus_models::TransactionPoolRecord::load(
             deserialize_hex_try_from(&self.transaction_id)?,
             evidence,
+            remote_evidence,
             self.transaction_fee.map(|f| f as u64),
             leader_fee,
             parse_from_string(&self.stage)?,
diff --git a/dan_layer/state_store_sqlite/src/writer.rs b/dan_layer/state_store_sqlite/src/writer.rs
index 687767e210..bb510a94c1 100644
--- a/dan_layer/state_store_sqlite/src/writer.rs
+++ b/dan_layer/state_store_sqlite/src/writer.rs
@@ -26,6 +26,7 @@ use tari_dan_storage::{
         Decision,
         EpochCheckpoint,
         Evidence,
+        ForeignParkedProposal,
         ForeignProposal,
         ForeignReceiveCounters,
         ForeignSendCounters,
@@ -242,13 +243,13 @@ impl<'tx, TAddr: NodeAddressable + 'tx> StateStoreWriteTransaction for SqliteSta
                               WHERE block_id == ?)
             WHERE block_id = ?"#,
         )
-        .bind::<Text, _>(serialize_hex(block.justify().block_id()))
-        .bind::<Text, _>(serialize_hex(block.id()))
-        .execute(self.connection())
-        .map_err(|e| SqliteStorageError::DieselError {
-            operation: "blocks_insert_set_delta_time",
-            source: e,
-        })?;
+            .bind::<Text, _>(serialize_hex(block.justify().block_id()))
+            .bind::<Text, _>(serialize_hex(block.id()))
+            .execute(self.connection())
+            .map_err(|e| SqliteStorageError::DieselError {
+                operation: "blocks_insert_set_delta_time",
+                source: e,
+            })?;
 
         Ok(())
     }
@@ -705,7 +706,7 @@ impl<'tx, TAddr: NodeAddressable + 'tx> StateStoreWriteTransaction for SqliteSta
         Ok(())
     }
 
-    fn transactions_save_all<'a, I: IntoIterator<Item = &'a TransactionRecord>>(
+    fn transactions_save_all<'a, I: IntoIterator<Item=&'a TransactionRecord>>(
         &mut self,
         txs: I,
     ) -> Result<(), StorageError> {
@@ -740,7 +741,7 @@ impl<'tx, TAddr: NodeAddressable + 'tx> StateStoreWriteTransaction for SqliteSta
         Ok(())
     }
 
-    fn transactions_finalize_all<'a, I: IntoIterator<Item = &'a TransactionPoolRecord>>(
+    fn transactions_finalize_all<'a, I: IntoIterator<Item=&'a TransactionPoolRecord>>(
         &mut self,
         block_id: BlockId,
         transactions: I,
@@ -919,7 +920,9 @@ impl<'tx, TAddr: NodeAddressable + 'tx> StateStoreWriteTransaction for SqliteSta
     fn transaction_pool_update(
         &mut self,
         transaction_id: &TransactionId,
+        is_ready: Option<bool>,
         local_decision: Option<Decision>,
+        local_evidence: Option<&Evidence>,
         remote_decision: Option<Decision>,
         remote_evidence: Option<&Evidence>,
     ) -> Result<(), StorageError> {
@@ -930,6 +933,8 @@ impl<'tx, TAddr: NodeAddressable + 'tx> StateStoreWriteTransaction for SqliteSta
         #[derive(AsChangeset)]
         #[diesel(table_name = transaction_pool)]
         struct Changes {
+            is_ready: Option<bool>,
+            evidence: Option<String>,
             remote_evidence: Option<String>,
             local_decision: Option<Option<String>>,
             remote_decision: Option<Option<String>>,
@@ -937,7 +942,9 @@ impl<'tx, TAddr: NodeAddressable + 'tx> StateStoreWriteTransaction for SqliteSta
         }
 
         let change_set = Changes {
+            is_ready,
             remote_evidence: remote_evidence.map(serialize_json).transpose()?,
+            evidence: local_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(),
@@ -992,7 +999,7 @@ impl<'tx, TAddr: NodeAddressable + 'tx> StateStoreWriteTransaction for SqliteSta
         Ok(())
     }
 
-    fn transaction_pool_remove_all<'a, I: IntoIterator<Item = &'a TransactionId>>(
+    fn transaction_pool_remove_all<'a, I: IntoIterator<Item=&'a TransactionId>>(
         &mut self,
         transaction_ids: I,
     ) -> Result<Vec<TransactionPoolRecord>, StorageError> {
@@ -1018,7 +1025,7 @@ impl<'tx, TAddr: NodeAddressable + 'tx> StateStoreWriteTransaction for SqliteSta
                     transaction_ids.len()
                 ),
             }
-            .into());
+                .into());
         }
 
         diesel::delete(transaction_pool_state_updates::table)
@@ -1032,7 +1039,7 @@ impl<'tx, TAddr: NodeAddressable + 'tx> StateStoreWriteTransaction for SqliteSta
         txs.into_iter().map(|tx| tx.try_convert(None)).collect()
     }
 
-    fn transaction_pool_confirm_all_transitions<'a, I: IntoIterator<Item = &'a TransactionId>>(
+    fn transaction_pool_confirm_all_transitions<'a, I: IntoIterator<Item=&'a TransactionId>>(
         &mut self,
         locked_block: &LockedBlock,
         new_locked_block: &LockedBlock,
@@ -1056,7 +1063,7 @@ impl<'tx, TAddr: NodeAddressable + 'tx> StateStoreWriteTransaction for SqliteSta
                 operation: "transaction_pool_set_all_transitions",
                 details: format!("Found {} transactions, but {} were queried", count, tx_ids.len()),
             }
-            .into());
+                .into());
         }
 
         let updates = self.get_transaction_atom_state_updates_between_blocks(
@@ -1120,8 +1127,8 @@ impl<'tx, TAddr: NodeAddressable + 'tx> StateStoreWriteTransaction for SqliteSta
 
     fn missing_transactions_insert<
         'a,
-        IMissing: IntoIterator<Item = &'a TransactionId>,
-        IAwaiting: IntoIterator<Item = &'a TransactionId>,
+        IMissing: IntoIterator<Item=&'a TransactionId>,
+        IAwaiting: IntoIterator<Item=&'a TransactionId>,
     >(
         &mut self,
         block: &Block,
@@ -1195,16 +1202,16 @@ impl<'tx, TAddr: NodeAddressable + 'tx> StateStoreWriteTransaction for SqliteSta
                 operation: "missing_transactions_remove",
                 source: e,
             })?;
-        let missing_transactions = missing_transactions::table
-            .select(missing_transactions::transaction_id)
+        let num_remaining = missing_transactions::table
             .filter(missing_transactions::block_id.eq(&block_id))
-            .get_results::<String>(self.connection())
+            .count()
+            .get_result::<i64>(self.connection())
             .map_err(|e| SqliteStorageError::DieselError {
                 operation: "missing_transactions_remove",
                 source: e,
             })?;
 
-        if missing_transactions.is_empty() {
+        if num_remaining == 0 {
             // delete all entries that are for previous heights
             diesel::delete(missing_transactions::table)
                 .filter(missing_transactions::block_height.lt(current_height.as_u64() as i64))
@@ -1220,6 +1227,110 @@ impl<'tx, TAddr: NodeAddressable + 'tx> StateStoreWriteTransaction for SqliteSta
         Ok(None)
     }
 
+    fn foreign_parked_blocks_insert(&mut self, park_block: &ForeignParkedProposal) -> Result<(), StorageError> {
+        use crate::schema::foreign_parked_blocks;
+
+        let values = (
+            foreign_parked_blocks::block_id.eq(serialize_hex(park_block.block().id())),
+            foreign_parked_blocks::block.eq(serialize_json(park_block.block())?),
+            foreign_parked_blocks::block_pledges.eq(serialize_json(park_block.block_pledge())?),
+            foreign_parked_blocks::justify_qc.eq(serialize_json(park_block.justify_qc())?),
+        );
+
+        diesel::insert_into(foreign_parked_blocks::table)
+            .values(values)
+            .execute(self.connection())
+            .map_err(|e| SqliteStorageError::DieselError {
+                operation: "foreign_parked_blocks_insert",
+                source: e,
+            })?;
+
+        Ok(())
+    }
+
+    fn foreign_parked_blocks_insert_missing_transactions<'a, I: IntoIterator<Item=&'a TransactionId>>(
+        &mut self,
+        park_block_id: &BlockId,
+        missing_transaction_ids: I,
+    ) -> Result<(), StorageError> {
+        use crate::schema::{foreign_missing_transactions, foreign_parked_blocks};
+
+        let parked_block_id = foreign_parked_blocks::table
+            .select(foreign_parked_blocks::id)
+            .filter(foreign_parked_blocks::block_id.eq(serialize_hex(park_block_id)))
+            .first::<i32>(self.connection())
+            .map_err(|e| SqliteStorageError::DieselError {
+                operation: "foreign_parked_blocks_insert_missing_transactions",
+                source: e,
+            })?;
+
+        let values = missing_transaction_ids
+            .into_iter()
+            .map(|tx_id| {
+                (
+                    foreign_missing_transactions::parked_block_id.eq(parked_block_id),
+                    foreign_missing_transactions::transaction_id.eq(serialize_hex(tx_id)),
+                )
+            })
+            .collect::<Vec<_>>();
+
+        diesel::insert_into(foreign_missing_transactions::table)
+            .values(values)
+            .execute(self.connection())
+            .map_err(|e| SqliteStorageError::DieselError {
+                operation: "foreign_parked_blocks_insert_missing_transactions",
+                source: e,
+            })?;
+
+        Ok(())
+    }
+
+    fn foreign_parked_blocks_remove_all_by_transaction(
+        &mut self,
+        transaction_id: &TransactionId,
+    ) -> Result<Vec<ForeignParkedProposal>, StorageError> {
+        use crate::schema::{foreign_missing_transactions, foreign_parked_blocks};
+
+        let transaction_id = serialize_hex(transaction_id);
+
+        let removed_ids = diesel::delete(foreign_missing_transactions::table)
+            .filter(foreign_missing_transactions::transaction_id.eq(&transaction_id))
+            .returning(foreign_missing_transactions::parked_block_id)
+            .get_results::<i32>(self.connection())
+            .map_err(|e| SqliteStorageError::DieselError {
+                operation: "foreign_parked_blocks_remove_all_by_transaction",
+                source: e,
+            })?;
+
+        if removed_ids.is_empty() {
+            return Ok(vec![]);
+        }
+
+        let num_remaining = foreign_missing_transactions::table
+            .filter(foreign_missing_transactions::parked_block_id.eq_any(&removed_ids))
+            .count()
+            .get_result::<i64>(self.connection())
+            .map_err(|e| SqliteStorageError::DieselError {
+                operation: "foreign_parked_blocks_remove_all_by_transaction",
+                source: e,
+            })?;
+
+        // If there are still missing transactions for the parked block, it is not yet unparked
+        if num_remaining > 0 {
+            return Ok(vec![]);
+        }
+
+        let blocks = diesel::delete(foreign_parked_blocks::table)
+            .filter(foreign_parked_blocks::id.eq_any(&removed_ids))
+            .get_results::<sql_models::ForeignParkedBlock>(self.connection())
+            .map_err(|e| SqliteStorageError::DieselError {
+                operation: "foreign_parked_blocks_remove_all_by_transaction",
+                source: e,
+            })?;
+
+        blocks.into_iter().map(TryInto::try_into).collect()
+    }
+
     fn votes_insert(&mut self, vote: &Vote) -> Result<(), StorageError> {
         use crate::schema::votes;
 
@@ -1243,7 +1354,7 @@ impl<'tx, TAddr: NodeAddressable + 'tx> StateStoreWriteTransaction for SqliteSta
         Ok(())
     }
 
-    fn substate_locks_insert_all<I: IntoIterator<Item = (SubstateId, Vec<SubstateLock>)>>(
+    fn substate_locks_insert_all<I: IntoIterator<Item=(SubstateId, Vec<SubstateLock>)>>(
         &mut self,
         block_id: BlockId,
         locks: I,
@@ -1292,7 +1403,7 @@ impl<'tx, TAddr: NodeAddressable + 'tx> StateStoreWriteTransaction for SqliteSta
         Ok(())
     }
 
-    fn substate_locks_remove_many_for_transactions<'a, I: Iterator<Item = &'a TransactionId>>(
+    fn substate_locks_remove_many_for_transactions<'a, I: Iterator<Item=&'a TransactionId>>(
         &mut self,
         mut transaction_ids: Peekable<I>,
     ) -> Result<(), StorageError> {
@@ -1315,7 +1426,7 @@ impl<'tx, TAddr: NodeAddressable + 'tx> StateStoreWriteTransaction for SqliteSta
         Ok(())
     }
 
-    fn substates_create(&mut self, substate: SubstateRecord) -> Result<(), StorageError> {
+    fn substates_create(&mut self, substate: &SubstateRecord) -> Result<(), StorageError> {
         use crate::schema::{state_transitions, substates};
 
         if substate.is_destroyed() {
@@ -1448,7 +1559,7 @@ impl<'tx, TAddr: NodeAddressable + 'tx> StateStoreWriteTransaction for SqliteSta
         Ok(())
     }
 
-    fn foreign_substate_pledges_insert(
+    fn foreign_substate_pledges_save(
         &mut self,
         transaction_id: TransactionId,
         shard_group: ShardGroup,
@@ -1457,51 +1568,52 @@ impl<'tx, TAddr: NodeAddressable + 'tx> StateStoreWriteTransaction for SqliteSta
         use crate::schema::foreign_substate_pledges;
         let tx_id_hex = serialize_hex(transaction_id);
 
-        let values = pledges
-            .into_iter()
-            .map(|pledge| match pledge {
-                SubstatePledge::Input {
-                    substate_id,
-                    is_write,
-                    substate,
-                } => {
-                    let lock_type = if is_write {
-                        SubstateLockType::Write
-                    } else {
-                        SubstateLockType::Read
-                    };
-                    Ok::<_, StorageError>((
-                        foreign_substate_pledges::transaction_id.eq(&tx_id_hex),
-                        foreign_substate_pledges::substate_id.eq(substate_id.substate_id().to_string()),
-                        foreign_substate_pledges::version.eq(substate_id.version() as i32),
-                        foreign_substate_pledges::shard_group.eq(shard_group.encode_as_u32() as i32),
-                        foreign_substate_pledges::lock_type.eq(lock_type.to_string()),
-                        foreign_substate_pledges::substate_value.eq(Some(serialize_json(&substate)?)),
-                    ))
-                },
-                SubstatePledge::Output { substate_id } => Ok::<_, StorageError>((
+        let values = pledges.into_iter().map(|pledge| match pledge {
+            SubstatePledge::Input {
+                substate_id,
+                is_write,
+                substate,
+            } => {
+                let lock_type = if is_write {
+                    SubstateLockType::Write
+                } else {
+                    SubstateLockType::Read
+                };
+                Ok::<_, StorageError>((
                     foreign_substate_pledges::transaction_id.eq(&tx_id_hex),
                     foreign_substate_pledges::substate_id.eq(substate_id.substate_id().to_string()),
                     foreign_substate_pledges::version.eq(substate_id.version() as i32),
                     foreign_substate_pledges::shard_group.eq(shard_group.encode_as_u32() as i32),
-                    foreign_substate_pledges::lock_type.eq(SubstateLockType::Output.to_string()),
-                    foreign_substate_pledges::substate_value.eq(None),
-                )),
-            })
-            .collect::<Result<Vec<_>, _>>()?;
-
-        diesel::insert_into(foreign_substate_pledges::table)
-            .values(values)
-            .execute(self.connection())
-            .map_err(|e| SqliteStorageError::DieselError {
-                operation: "foreign_substate_pledges_insert",
-                source: e,
-            })?;
+                    foreign_substate_pledges::lock_type.eq(lock_type.to_string()),
+                    foreign_substate_pledges::substate_value.eq(Some(serialize_json(&substate)?)),
+                ))
+            }
+            SubstatePledge::Output { substate_id } => Ok::<_, StorageError>((
+                foreign_substate_pledges::transaction_id.eq(&tx_id_hex),
+                foreign_substate_pledges::substate_id.eq(substate_id.substate_id().to_string()),
+                foreign_substate_pledges::version.eq(substate_id.version() as i32),
+                foreign_substate_pledges::shard_group.eq(shard_group.encode_as_u32() as i32),
+                foreign_substate_pledges::lock_type.eq(SubstateLockType::Output.to_string()),
+                foreign_substate_pledges::substate_value.eq(None),
+            )),
+        });
+
+        for value in values {
+            diesel::insert_into(foreign_substate_pledges::table)
+                .values(value?)
+                // This is not supported for batch inserts, which is why we do multiple inserts
+                .on_conflict_do_nothing()
+                .execute(self.connection())
+                .map_err(|e| SqliteStorageError::DieselError {
+                    operation: "foreign_substate_pledges_insert",
+                    source: e,
+                })?;
+        }
 
         Ok(())
     }
 
-    fn foreign_substate_pledges_remove_many<'a, I: IntoIterator<Item = &'a TransactionId>>(
+    fn foreign_substate_pledges_remove_many<'a, I: IntoIterator<Item=&'a TransactionId>>(
         &mut self,
         transaction_ids: I,
     ) -> Result<(), StorageError> {
diff --git a/dan_layer/storage/src/consensus_models/block.rs b/dan_layer/storage/src/consensus_models/block.rs
index e08d5f14ee..8fe1c5ac78 100644
--- a/dan_layer/storage/src/consensus_models/block.rs
+++ b/dan_layer/storage/src/consensus_models/block.rs
@@ -15,6 +15,7 @@ use tari_common::configuration::Network;
 use tari_common_types::types::{FixedHash, FixedHashSizeError, PublicKey};
 use tari_crypto::tari_utilities::epoch_time::EpochTime;
 use tari_dan_common_types::{
+    committee::CommitteeInfo,
     hashing,
     optional::Optional,
     serde_with,
@@ -344,6 +345,21 @@ impl Block {
         self.commands.iter().filter_map(|d| d.transaction().map(|t| t.id()))
     }
 
+    pub fn all_transaction_ids_in_committee<'a>(
+        &'a self,
+        committee_info: &'a CommitteeInfo,
+    ) -> impl Iterator<Item = &TransactionId> + 'a {
+        self.commands
+            .iter()
+            .filter_map(|cmd| cmd.transaction())
+            .filter(|t| {
+                t.evidence
+                    .substate_addresses_iter()
+                    .any(|addr| committee_info.includes_substate_address(addr))
+            })
+            .map(|t| t.id())
+    }
+
     pub fn all_committing_transactions_ids(&self) -> impl Iterator<Item = &TransactionId> + '_ {
         self.commands.iter().filter_map(|d| d.committing()).map(|t| t.id())
     }
@@ -940,7 +956,11 @@ impl Block {
         tx: &TTx,
     ) -> Result<BlockPledge, StorageError> {
         let mut pledges = BlockPledge::new();
-        for atom in self.commands().iter().filter_map(|cmd| cmd.local_prepare()) {
+        for atom in self
+            .commands()
+            .iter()
+            .filter_map(|cmd| cmd.local_prepare().or_else(|| cmd.local_accept()))
+        {
             // No pledges for aborted transactions
             if atom.decision.is_abort() {
                 continue;
diff --git a/dan_layer/storage/src/consensus_models/block_pledges.rs b/dan_layer/storage/src/consensus_models/block_pledges.rs
index e93dd914c1..8c19bd4fd1 100644
--- a/dan_layer/storage/src/consensus_models/block_pledges.rs
+++ b/dan_layer/storage/src/consensus_models/block_pledges.rs
@@ -7,14 +7,14 @@ use std::{
     hash::Hash,
 };
 
-use serde::Serialize;
+use serde::{Deserialize, Serialize};
 use tari_engine_types::substate::{SubstateId, SubstateValue};
 use tari_transaction::{SubstateRequirement, TransactionId, VersionedSubstateId};
 
 use crate::consensus_models::{SubstateLockType, VersionedSubstateIdLockIntent};
 #[allow(clippy::mutable_key_type)]
 pub type SubstatePledges = HashSet<SubstatePledge>;
-#[derive(Debug, Clone, Serialize, Default)]
+#[derive(Debug, Clone, Serialize, Deserialize, Default)]
 pub struct BlockPledge {
     pledges: HashMap<TransactionId, SubstatePledges>,
 }
@@ -59,7 +59,7 @@ impl FromIterator<(TransactionId, SubstatePledges)> for BlockPledge {
     }
 }
 
-#[derive(Debug, Clone, Serialize)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
 pub enum SubstatePledge {
     Input {
         substate_id: VersionedSubstateId,
@@ -149,9 +149,9 @@ impl Display for SubstatePledge {
                 substate_id, is_write, ..
             } => {
                 if *is_write {
-                    write!(f, "Write input: {}", substate_id)
+                    write!(f, "Write: {}", substate_id)
                 } else {
-                    write!(f, "Read input: {}", substate_id)
+                    write!(f, "Read: {}", substate_id)
                 }
             },
             SubstatePledge::Output { substate_id } => write!(f, "Output: {}", substate_id),
diff --git a/dan_layer/storage/src/consensus_models/command.rs b/dan_layer/storage/src/consensus_models/command.rs
index ccc2736e39..39bf23248e 100644
--- a/dan_layer/storage/src/consensus_models/command.rs
+++ b/dan_layer/storage/src/consensus_models/command.rs
@@ -2,214 +2,20 @@
 //   SPDX-License-Identifier: BSD-3-Clause
 
 use std::{
-    borrow::Borrow,
     cmp::Ordering,
     fmt::{Display, Formatter},
 };
 
-use indexmap::{IndexMap, IndexSet};
 use serde::{Deserialize, Serialize};
-use tari_dan_common_types::SubstateAddress;
 use tari_transaction::TransactionId;
 
-use super::{
-    BlockId,
-    ExecutedTransaction,
-    ForeignProposal,
-    LeaderFee,
-    SubstateLockType,
-    TransactionRecord,
-    VersionedSubstateIdLockIntent,
-};
+use super::{BlockId, ExecutedTransaction, ForeignProposal, LeaderFee, TransactionRecord};
 use crate::{
-    consensus_models::{Decision, QcId},
+    consensus_models::{evidence::Evidence, Decision},
     StateStoreReadTransaction,
     StorageError,
 };
 
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Default)]
-#[cfg_attr(
-    feature = "ts",
-    derive(ts_rs::TS),
-    ts(export, export_to = "../../bindings/src/types/")
-)]
-pub struct Evidence {
-    evidence: IndexMap<SubstateAddress, ShardEvidence>,
-}
-
-impl Evidence {
-    pub fn empty() -> Self {
-        Self {
-            evidence: IndexMap::new(),
-        }
-    }
-
-    pub fn from_inputs_and_outputs<
-        I: IntoIterator<Item = BI>,
-        BI: Borrow<VersionedSubstateIdLockIntent>,
-        O: IntoIterator<Item = BO>,
-        BO: Borrow<VersionedSubstateIdLockIntent>,
-    >(
-        resolved_inputs: I,
-        resulting_outputs: O,
-    ) -> Self {
-        resolved_inputs
-            .into_iter()
-            .map(|input| {
-                let i = input.borrow();
-                (i.to_substate_address(), ShardEvidence {
-                    qc_ids: IndexSet::new(),
-                    lock: i.lock_type(),
-                })
-            })
-            .chain(resulting_outputs.into_iter().map(|output| {
-                let o = output.borrow();
-                (o.to_substate_address(), ShardEvidence {
-                    qc_ids: IndexSet::new(),
-                    lock: o.lock_type(),
-                })
-            }))
-            .collect()
-    }
-
-    pub fn all_addresses_justified(&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())
-    }
-
-    pub fn is_empty(&self) -> bool {
-        self.evidence.is_empty()
-    }
-
-    pub fn len(&self) -> usize {
-        self.evidence.len()
-    }
-
-    pub fn get(&self, substate_address: &SubstateAddress) -> Option<&ShardEvidence> {
-        self.evidence.get(substate_address)
-    }
-
-    pub fn num_justified_shards(&self) -> usize {
-        self.evidence
-            .values()
-            .filter(|evidence| !evidence.qc_ids.is_empty())
-            .count()
-    }
-
-    pub fn iter(&self) -> impl Iterator<Item = (&SubstateAddress, &ShardEvidence)> {
-        self.evidence.iter()
-    }
-
-    pub fn iter_mut(&mut self) -> impl Iterator<Item = (&SubstateAddress, &mut ShardEvidence)> {
-        self.evidence.iter_mut()
-    }
-
-    /// Returns an iterator over the substate addresses in this Evidence object.
-    /// NOTE: not all substates involved in the final transaction are necessarily included in this Evidence object until
-    /// the transaction has reached AllAccepted state.
-    pub fn substate_addresses_iter(&self) -> impl Iterator<Item = &SubstateAddress> + '_ {
-        self.evidence.keys()
-    }
-
-    pub fn contains(&self, substate_address: &SubstateAddress) -> bool {
-        self.evidence.contains_key(substate_address)
-    }
-
-    pub fn qc_ids_iter(&self) -> impl Iterator<Item = &QcId> + '_ {
-        self.evidence.values().flat_map(|e| e.qc_ids.iter())
-    }
-
-    /// Add or update substate addresses and locks into Evidence
-    pub fn update<I: IntoIterator<Item = (SubstateAddress, SubstateLockType)>>(&mut self, extend: I) -> &mut Self {
-        for (substate_address, lock_type) in extend {
-            self.evidence
-                .entry(substate_address)
-                .and_modify(|evidence| evidence.lock = lock_type)
-                .or_insert_with(|| ShardEvidence {
-                    qc_ids: IndexSet::new(),
-                    lock: lock_type,
-                });
-        }
-        self
-    }
-
-    /// Merges the other Evidence into this Evidence. If a substate address is present in both, the lock type is
-    /// updated to the lock type and the QCs are appended to this instance.
-    pub fn merge(&mut self, other: Evidence) -> &mut Self {
-        for (substate_address, shard_evidence) in other.evidence {
-            let entry = self
-                .evidence
-                .entry(substate_address)
-                .and_modify(|evidence| {
-                    evidence.lock = shard_evidence.lock;
-                })
-                .or_insert_with(|| ShardEvidence {
-                    qc_ids: IndexSet::new(),
-                    lock: shard_evidence.lock,
-                });
-            entry.qc_ids.extend(shard_evidence.qc_ids);
-        }
-        self
-    }
-}
-
-impl FromIterator<(SubstateAddress, ShardEvidence)> for Evidence {
-    fn from_iter<T: IntoIterator<Item = (SubstateAddress, ShardEvidence)>>(iter: T) -> Self {
-        let mut evidence = iter.into_iter().collect::<IndexMap<_, _>>();
-        evidence.sort_keys();
-        Evidence { evidence }
-    }
-}
-
-impl Display for Evidence {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{{")?;
-        for (i, (substate_address, shard_evidence)) in self.evidence.iter().enumerate() {
-            if i > 0 {
-                write!(f, ", ")?;
-            }
-            write!(f, "{}: {}", substate_address, shard_evidence)?;
-        }
-        write!(f, "}}")
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-#[cfg_attr(
-    feature = "ts",
-    derive(ts_rs::TS),
-    ts(export, export_to = "../../bindings/src/types/")
-)]
-pub struct ShardEvidence {
-    #[cfg_attr(feature = "ts", ts(type = "Array<string>"))]
-    pub qc_ids: IndexSet<QcId>,
-    pub lock: SubstateLockType,
-}
-
-impl ShardEvidence {
-    pub fn new(qc_ids: IndexSet<QcId>, lock: SubstateLockType) -> Self {
-        Self { qc_ids, lock }
-    }
-
-    pub fn is_empty(&self) -> bool {
-        self.qc_ids.is_empty()
-    }
-
-    pub fn contains(&self, qc_id: &QcId) -> bool {
-        self.qc_ids.contains(qc_id)
-    }
-
-    pub fn insert(&mut self, qc_id: QcId) {
-        self.qc_ids.insert(qc_id);
-    }
-}
-
-impl Display for ShardEvidence {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        write!(f, "({}, {} QC(s))", self.lock, self.qc_ids.len())
-    }
-}
-
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 #[cfg_attr(
     feature = "ts",
@@ -344,6 +150,13 @@ impl Command {
         }
     }
 
+    pub fn local_only(&self) -> Option<&TransactionAtom> {
+        match self {
+            Command::LocalOnly(tx) => Some(tx),
+            _ => None,
+        }
+    }
+
     pub fn prepare(&self) -> Option<&TransactionAtom> {
         match self {
             Command::Prepare(tx) => Some(tx),
@@ -379,13 +192,6 @@ impl Command {
         }
     }
 
-    pub fn local_only(&self) -> Option<&TransactionAtom> {
-        match self {
-            Command::LocalOnly(tx) => Some(tx),
-            _ => None,
-        }
-    }
-
     pub fn all_accept(&self) -> Option<&TransactionAtom> {
         match self {
             Command::AllAccept(tx) => Some(tx),
@@ -400,6 +206,22 @@ impl Command {
         }
     }
 
+    /// Returns Some if the command should NOT result in finalising the transaction, otherwise None.
+    pub fn progressing(&self) -> Option<&TransactionAtom> {
+        match self {
+            Command::Prepare(tx) |
+            Command::LocalPrepare(tx) |
+            Command::AllPrepare(tx) |
+            Command::SomePrepare(tx) |
+            Command::LocalAccept(tx) => Some(tx),
+            Command::LocalOnly(_) |
+            Command::AllAccept(_) |
+            Command::SomeAccept(_) |
+            Command::EndEpoch |
+            Command::ForeignProposal(_) => None,
+        }
+    }
+
     /// Returns Some if the command should result in finalising (COMMITing or ABORTing) the transaction, otherwise None.
     pub fn finalising(&self) -> Option<&TransactionAtom> {
         self.all_accept()
@@ -418,6 +240,14 @@ impl Command {
         matches!(self, Command::EndEpoch)
     }
 
+    pub fn is_local_prepare(&self) -> bool {
+        matches!(self, Command::LocalPrepare(_))
+    }
+
+    pub fn is_local_accept(&self) -> bool {
+        matches!(self, Command::LocalAccept(_))
+    }
+
     pub fn evidence(&self) -> &Evidence {
         match self {
             Command::Prepare(tx) |
diff --git a/dan_layer/storage/src/consensus_models/evidence.rs b/dan_layer/storage/src/consensus_models/evidence.rs
new file mode 100644
index 0000000000..fdceea4043
--- /dev/null
+++ b/dan_layer/storage/src/consensus_models/evidence.rs
@@ -0,0 +1,253 @@
+//   Copyright 2024 The Tari Project
+//   SPDX-License-Identifier: BSD-3-Clause
+
+use std::{
+    borrow::Borrow,
+    fmt::{Display, Formatter},
+};
+
+use indexmap::{IndexMap, IndexSet};
+use serde::{Deserialize, Serialize};
+use tari_dan_common_types::{committee::CommitteeInfo, SubstateAddress};
+
+use crate::consensus_models::{QcId, SubstateLockType, VersionedSubstateIdLockIntent};
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Default)]
+#[cfg_attr(
+    feature = "ts",
+    derive(ts_rs::TS),
+    ts(export, export_to = "../../bindings/src/types/")
+)]
+pub struct Evidence {
+    evidence: IndexMap<SubstateAddress, ShardEvidence>,
+}
+
+impl Evidence {
+    pub fn empty() -> Self {
+        Self {
+            evidence: IndexMap::new(),
+        }
+    }
+
+    pub fn from_inputs_and_outputs<
+        I: IntoIterator<Item = BI>,
+        BI: Borrow<VersionedSubstateIdLockIntent>,
+        O: IntoIterator<Item = BO>,
+        BO: Borrow<VersionedSubstateIdLockIntent>,
+    >(
+        resolved_inputs: I,
+        resulting_outputs: O,
+    ) -> Self {
+        resolved_inputs
+            .into_iter()
+            .map(|input| {
+                let i = input.borrow();
+                (i.to_substate_address(), ShardEvidence {
+                    qc_ids: IndexSet::new(),
+                    lock: i.lock_type(),
+                })
+            })
+            .chain(resulting_outputs.into_iter().map(|output| {
+                let o = output.borrow();
+                (o.to_substate_address(), ShardEvidence {
+                    qc_ids: IndexSet::new(),
+                    lock: o.lock_type(),
+                })
+            }))
+            .collect()
+    }
+
+    pub fn all_addresses_justified(&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())
+    }
+
+    pub fn all_input_addresses_justified(&self) -> bool {
+        self.evidence
+            .values()
+            .filter(|e| !e.lock.is_output())
+            .all(|qc_ids| !qc_ids.is_empty())
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.evidence.is_empty()
+    }
+
+    pub fn len(&self) -> usize {
+        self.evidence.len()
+    }
+
+    pub fn get(&self, substate_address: &SubstateAddress) -> Option<&ShardEvidence> {
+        self.evidence.get(substate_address)
+    }
+
+    pub fn num_justified_shards(&self) -> usize {
+        self.evidence
+            .values()
+            .filter(|evidence| !evidence.qc_ids.is_empty())
+            .count()
+    }
+
+    pub fn iter(&self) -> impl Iterator<Item = (&SubstateAddress, &ShardEvidence)> {
+        self.evidence.iter()
+    }
+
+    pub fn iter_mut(&mut self) -> impl Iterator<Item = (&SubstateAddress, &mut ShardEvidence)> {
+        self.evidence.iter_mut()
+    }
+
+    pub fn add_qc_evidence(&mut self, committee_info: &CommitteeInfo, qc_id: QcId) -> &mut Self {
+        for (address, evidence_mut) in self.iter_mut() {
+            if committee_info.includes_substate_address(address) {
+                evidence_mut.qc_ids.insert(qc_id);
+            }
+        }
+
+        self
+    }
+
+    /// Returns an iterator over the substate addresses in this Evidence object.
+    /// NOTE: not all substates involved in the final transaction are necessarily included in this Evidence object until
+    /// the transaction has reached AllAccepted state.
+    pub fn substate_addresses_iter(&self) -> impl Iterator<Item = &SubstateAddress> + '_ {
+        self.evidence.keys()
+    }
+
+    pub fn contains(&self, substate_address: &SubstateAddress) -> bool {
+        self.evidence.contains_key(substate_address)
+    }
+
+    pub fn qc_ids_iter(&self) -> impl Iterator<Item = &QcId> + '_ {
+        self.evidence.values().flat_map(|e| e.qc_ids.iter())
+    }
+
+    /// Add or update substate addresses and locks into Evidence
+    pub fn update<I: IntoIterator<Item = (SubstateAddress, SubstateLockType)>>(&mut self, extend: I) -> &mut Self {
+        for (substate_address, lock_type) in extend {
+            self.evidence
+                .entry(substate_address)
+                .and_modify(|evidence| evidence.lock = lock_type)
+                .or_insert_with(|| ShardEvidence {
+                    qc_ids: IndexSet::new(),
+                    lock: lock_type,
+                });
+        }
+        self
+    }
+
+    /// Merges the other Evidence into this Evidence. If a substate address is present in both, the lock type is
+    /// updated to the lock type and the QCs are appended to this instance.
+    pub fn merge(&mut self, other: Evidence) -> &mut Self {
+        for (substate_address, shard_evidence) in other.evidence {
+            let entry = self
+                .evidence
+                .entry(substate_address)
+                .and_modify(|evidence| {
+                    evidence.lock = shard_evidence.lock;
+                })
+                .or_insert_with(|| ShardEvidence {
+                    qc_ids: IndexSet::new(),
+                    lock: shard_evidence.lock,
+                });
+            entry.qc_ids.extend(shard_evidence.qc_ids);
+        }
+        self
+    }
+}
+
+impl FromIterator<(SubstateAddress, ShardEvidence)> for Evidence {
+    fn from_iter<T: IntoIterator<Item = (SubstateAddress, ShardEvidence)>>(iter: T) -> Self {
+        let mut evidence = iter.into_iter().collect::<IndexMap<_, _>>();
+        evidence.sort_keys();
+        Evidence { evidence }
+    }
+}
+
+impl Display for Evidence {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{{")?;
+        for (i, (substate_address, shard_evidence)) in self.evidence.iter().enumerate() {
+            if i > 0 {
+                write!(f, ", ")?;
+            }
+            write!(f, "{}: {}", substate_address, shard_evidence)?;
+        }
+        write!(f, "}}")
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[cfg_attr(
+    feature = "ts",
+    derive(ts_rs::TS),
+    ts(export, export_to = "../../bindings/src/types/")
+)]
+pub struct ShardEvidence {
+    #[cfg_attr(feature = "ts", ts(type = "Array<string>"))]
+    pub qc_ids: IndexSet<QcId>,
+    pub lock: SubstateLockType,
+}
+
+impl ShardEvidence {
+    pub fn new(qc_ids: IndexSet<QcId>, lock: SubstateLockType) -> Self {
+        Self { qc_ids, lock }
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.qc_ids.is_empty()
+    }
+
+    pub fn contains(&self, qc_id: &QcId) -> bool {
+        self.qc_ids.contains(qc_id)
+    }
+
+    pub fn insert(&mut self, qc_id: QcId) {
+        self.qc_ids.insert(qc_id);
+    }
+}
+
+impl Display for ShardEvidence {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "({}, {} QC(s))", self.lock, self.qc_ids.len())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn seed_substate_address(seed: u8) -> SubstateAddress {
+        SubstateAddress::from_bytes(&[seed; SubstateAddress::LENGTH]).unwrap()
+    }
+
+    #[test]
+    fn it_merges_two_evidences_together() {
+        let mut evidence1 = Evidence::empty();
+        evidence1.update(vec![
+            (seed_substate_address(1), SubstateLockType::Write),
+            (seed_substate_address(2), SubstateLockType::Read),
+        ]);
+
+        let mut evidence2 = Evidence::empty();
+        evidence2.update(vec![
+            (seed_substate_address(2), SubstateLockType::Output),
+            (seed_substate_address(3), SubstateLockType::Output),
+        ]);
+
+        evidence1.merge(evidence2);
+
+        assert_eq!(evidence1.len(), 3);
+        assert_eq!(
+            evidence1.get(&seed_substate_address(1)).unwrap().lock,
+            SubstateLockType::Write
+        );
+        assert_eq!(
+            evidence1.get(&seed_substate_address(2)).unwrap().lock,
+            SubstateLockType::Output
+        );
+        assert_eq!(
+            evidence1.get(&seed_substate_address(3)).unwrap().lock,
+            SubstateLockType::Output
+        );
+    }
+}
diff --git a/dan_layer/storage/src/consensus_models/foreign_parked_proposal.rs b/dan_layer/storage/src/consensus_models/foreign_parked_proposal.rs
new file mode 100644
index 0000000000..15f9a64f1b
--- /dev/null
+++ b/dan_layer/storage/src/consensus_models/foreign_parked_proposal.rs
@@ -0,0 +1,77 @@
+//    Copyright 2024 The Tari Project
+//    SPDX-License-Identifier: BSD-3-Clause
+
+use std::fmt::Display;
+
+use tari_transaction::TransactionId;
+
+use crate::{
+    consensus_models::{Block, BlockPledge, QuorumCertificate},
+    StateStoreWriteTransaction,
+    StorageError,
+};
+
+#[derive(Debug, Clone)]
+pub struct ForeignParkedProposal {
+    pub block: Block,
+    pub block_pledge: BlockPledge,
+    pub justify_qc: QuorumCertificate,
+}
+
+impl ForeignParkedProposal {
+    pub fn new(block: Block, justify_qc: QuorumCertificate, block_pledge: BlockPledge) -> Self {
+        Self {
+            block,
+            block_pledge,
+            justify_qc,
+        }
+    }
+
+    pub fn block(&self) -> &Block {
+        &self.block
+    }
+
+    pub fn block_pledge(&self) -> &BlockPledge {
+        &self.block_pledge
+    }
+
+    pub fn justify_qc(&self) -> &QuorumCertificate {
+        &self.justify_qc
+    }
+}
+
+impl ForeignParkedProposal {
+    pub fn insert<TTx: StateStoreWriteTransaction>(&self, tx: &mut TTx) -> Result<(), StorageError> {
+        tx.foreign_parked_blocks_insert(self)
+    }
+
+    pub fn add_missing_transactions<'a, TTx: StateStoreWriteTransaction, I: IntoIterator<Item = &'a TransactionId>>(
+        &self,
+        tx: &mut TTx,
+        transaction_ids: I,
+    ) -> Result<(), StorageError> {
+        tx.foreign_parked_blocks_insert_missing_transactions(self.block.id(), transaction_ids)
+    }
+
+    pub fn remove_by_transaction_id<TTx: StateStoreWriteTransaction>(
+        tx: &mut TTx,
+        transaction_id: &TransactionId,
+    ) -> Result<Vec<Self>, StorageError> {
+        tx.foreign_parked_blocks_remove_all_by_transaction(transaction_id)
+    }
+}
+
+impl Display for ForeignParkedProposal {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "ForeignParkedBlock: block={}, qcs=", self.block)?;
+        for (_tx_id, pledges) in self.block_pledge().iter() {
+            write!(f, "{_tx_id}:[")?;
+            for pledge in pledges {
+                write!(f, "{pledge}, ")?;
+            }
+            write!(f, "],")?;
+        }
+        write!(f, "justify_qc={}", self.justify_qc)?;
+        Ok(())
+    }
+}
diff --git a/dan_layer/storage/src/consensus_models/mod.rs b/dan_layer/storage/src/consensus_models/mod.rs
index b2d9f3ba44..8e4349bab3 100644
--- a/dan_layer/storage/src/consensus_models/mod.rs
+++ b/dan_layer/storage/src/consensus_models/mod.rs
@@ -6,7 +6,9 @@ mod block_diff;
 mod block_pledges;
 mod command;
 mod epoch_checkpoint;
+mod evidence;
 mod executed_transaction;
+mod foreign_parked_proposal;
 mod foreign_proposal;
 mod foreign_receive_counters;
 mod foreign_send_counters;
@@ -39,7 +41,9 @@ pub use block_diff::*;
 pub use block_pledges::*;
 pub use command::*;
 pub use epoch_checkpoint::*;
+pub use evidence::*;
 pub use executed_transaction::*;
+pub use foreign_parked_proposal::*;
 pub use foreign_proposal::*;
 pub use foreign_receive_counters::*;
 pub use foreign_send_counters::*;
diff --git a/dan_layer/storage/src/consensus_models/substate.rs b/dan_layer/storage/src/consensus_models/substate.rs
index 757c82f230..7cbc630c5d 100644
--- a/dan_layer/storage/src/consensus_models/substate.rs
+++ b/dan_layer/storage/src/consensus_models/substate.rs
@@ -175,7 +175,7 @@ impl SubstateRecord {
         tx.substate_locks_remove_many_for_transactions(transaction_ids)
     }
 
-    pub fn create<TTx: StateStoreWriteTransaction>(self, tx: &mut TTx) -> Result<(), StorageError> {
+    pub fn create<TTx: StateStoreWriteTransaction>(&self, tx: &mut TTx) -> Result<(), StorageError> {
         tx.substates_create(self)?;
         Ok(())
     }
diff --git a/dan_layer/storage/src/consensus_models/transaction.rs b/dan_layer/storage/src/consensus_models/transaction.rs
index 9cdf350050..7caa639929 100644
--- a/dan_layer/storage/src/consensus_models/transaction.rs
+++ b/dan_layer/storage/src/consensus_models/transaction.rs
@@ -3,9 +3,13 @@
 
 use std::{collections::HashSet, ops::Deref, time::Duration};
 
+use log::*;
 use serde::Deserialize;
 use tari_dan_common_types::committee::CommitteeInfo;
-use tari_engine_types::commit_result::{ExecuteResult, FinalizeResult, RejectReason};
+use tari_engine_types::{
+    commit_result::{ExecuteResult, FinalizeResult, RejectReason},
+    transaction_receipt::TransactionReceiptAddress,
+};
 use tari_transaction::{Transaction, TransactionId};
 
 use crate::{
@@ -26,6 +30,8 @@ use crate::{
     StorageError,
 };
 
+const LOG_TARGET: &str = "tari::dan::storage::consensus_models::transaction";
+
 #[derive(Debug, Clone, Deserialize)]
 pub struct TransactionRecord {
     pub transaction: Transaction,
@@ -152,7 +158,11 @@ impl TransactionRecord {
     pub fn has_any_local_inputs(&self, local_committee_info: &CommitteeInfo) -> bool {
         self.transaction
             .all_inputs_iter()
-            .any(|i| local_committee_info.includes_substate_address(&i.to_substate_address_default_version(0)))
+            .any(|i| local_committee_info.includes_substate_id(i.substate_id()))
+    }
+
+    pub fn to_receipt_id(&self) -> TransactionReceiptAddress {
+        (*self.id()).into()
     }
 
     pub fn into_execution(mut self) -> Option<TransactionExecution> {
@@ -360,6 +370,12 @@ impl TransactionRecord {
         let pledges = tx.foreign_substate_pledges_get_all_by_transaction_id(self.id())?;
         for input in foreign_inputs {
             if !pledges.iter().any(|p| *p == input) {
+                debug!(
+                    target: LOG_TARGET,
+                    "Transaction {} is missing a pledge for input {}",
+                    self.id(),
+                    input.substate_id()
+                );
                 return Ok(false);
             }
         }
diff --git a/dan_layer/storage/src/consensus_models/transaction_pool.rs b/dan_layer/storage/src/consensus_models/transaction_pool.rs
index 22649ef3a6..ba3bc09893 100644
--- a/dan_layer/storage/src/consensus_models/transaction_pool.rs
+++ b/dan_layer/storage/src/consensus_models/transaction_pool.rs
@@ -234,6 +234,18 @@ impl TransactionPoolStage {
     pub fn is_all_prepared(&self) -> bool {
         matches!(self, Self::AllPrepared)
     }
+
+    pub fn is_all_accepted(&self) -> bool {
+        matches!(self, Self::AllAccepted)
+    }
+
+    pub fn is_some_accepted(&self) -> bool {
+        matches!(self, Self::SomeAccepted)
+    }
+
+    pub fn is_finalising(&self) -> bool {
+        self.is_local_only() || self.is_all_accepted() || self.is_some_accepted()
+    }
 }
 
 impl Display for TransactionPoolStage {
@@ -306,6 +318,7 @@ pub struct TransactionPoolRecord {
     #[cfg_attr(feature = "ts", ts(type = "string"))]
     transaction_id: TransactionId,
     evidence: Evidence,
+    remote_evidence: Option<Evidence>,
     #[cfg_attr(feature = "ts", ts(type = "number"))]
     transaction_fee: u64,
     leader_fee: Option<LeaderFee>,
@@ -321,6 +334,7 @@ impl TransactionPoolRecord {
     pub fn load(
         id: TransactionId,
         evidence: Evidence,
+        remote_evidence: Option<Evidence>,
         transaction_fee: Option<u64>,
         leader_fee: Option<LeaderFee>,
         stage: TransactionPoolStage,
@@ -333,6 +347,7 @@ impl TransactionPoolRecord {
         Self {
             transaction_id: id,
             evidence,
+            remote_evidence,
             transaction_fee: transaction_fee.unwrap_or(0),
             leader_fee,
             stage,
@@ -513,13 +528,7 @@ impl TransactionPoolRecord {
     }
 
     pub fn add_qc_evidence(&mut self, committee_info: &CommitteeInfo, qc_id: QcId) -> &mut Self {
-        let evidence = &mut self.evidence;
-        for (address, evidence_mut) in evidence.iter_mut() {
-            if committee_info.includes_substate_address(address) {
-                evidence_mut.qc_ids.insert(qc_id);
-            }
-        }
-
+        self.evidence.add_qc_evidence(committee_info, qc_id);
         self
     }
 
@@ -536,7 +545,7 @@ impl TransactionPoolRecord {
             // Prepared
             ((TransactionPoolStage::Prepared, TransactionPoolStage::LocalPrepared), _) |
             // LocalPrepared
-            ((TransactionPoolStage::LocalPrepared, TransactionPoolStage::LocalPrepared), true) |
+            ((TransactionPoolStage::LocalPrepared, TransactionPoolStage::LocalPrepared), _) |
             ((TransactionPoolStage::LocalPrepared, TransactionPoolStage::AllPrepared), _) |
             ((TransactionPoolStage::LocalPrepared, TransactionPoolStage::SomePrepared), _) |
             // AllPrepared
@@ -546,8 +555,8 @@ impl TransactionPoolRecord {
             ((TransactionPoolStage::SomePrepared, TransactionPoolStage::SomePrepared), false) |
             ((TransactionPoolStage::SomePrepared, TransactionPoolStage::LocalAccepted), _) |
             // LocalAccepted
-            ((TransactionPoolStage::LocalAccepted, TransactionPoolStage::LocalAccepted), true) |
-            ((TransactionPoolStage::LocalAccepted, TransactionPoolStage::AllAccepted), _) |
+            ((TransactionPoolStage::LocalAccepted, TransactionPoolStage::LocalAccepted), _) |
+            ((TransactionPoolStage::LocalAccepted, TransactionPoolStage::AllAccepted), false) |
             ((TransactionPoolStage::LocalAccepted, TransactionPoolStage::SomeAccepted), false) |
             // Accepted
             ((TransactionPoolStage::AllAccepted, TransactionPoolStage::AllAccepted), false) => {}
@@ -597,32 +606,61 @@ impl TransactionPoolRecord {
         foreign_committee_info: &CommitteeInfo,
         remote_evidence: Evidence,
     ) -> Result<(), TransactionPoolError> {
-        self.evidence.merge(remote_evidence);
+        match self.remote_evidence.as_mut() {
+            Some(evidence) => {
+                evidence.merge(remote_evidence);
+            },
+            None => {
+                self.remote_evidence = Some(remote_evidence);
+            },
+        }
+
+        tx.transaction_pool_update(
+            &self.transaction_id,
+            None,
+            None,
+            None,
+            Some(decision),
+            self.remote_evidence.as_ref(),
+        )?;
+        // TODO: we should not blindly use unknown foreign QCs
+        self.evidence
+            .merge(self.remote_evidence.as_ref().expect("set above").clone());
         self.add_qc_evidence(foreign_committee_info, foreign_qc_id);
         self.set_remote_decision(decision);
-        tx.transaction_pool_update(&self.transaction_id, None, Some(decision), Some(&self.evidence))?;
         Ok(())
     }
 
     #[allow(clippy::mutable_key_type)]
     pub fn add_foreign_pledges<TTx: StateStoreWriteTransaction>(
-        &mut self,
+        &self,
         tx: &mut TTx,
         shard_group: ShardGroup,
         foreign_pledges: SubstatePledges,
     ) -> Result<(), TransactionPoolError> {
-        tx.foreign_substate_pledges_insert(self.transaction_id, shard_group, foreign_pledges)?;
+        tx.foreign_substate_pledges_save(self.transaction_id, shard_group, foreign_pledges)?;
         Ok(())
     }
 
-    pub fn update_local_decision<TTx: StateStoreWriteTransaction>(
+    pub fn update_local_data<TTx: StateStoreWriteTransaction>(
         &mut self,
         tx: &mut TTx,
-        decision: Decision,
+        is_ready: bool,
     ) -> 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, Some(decision), None, None)?;
+        if self
+            .local_decision
+            .map(|d| d != self.current_decision())
+            .unwrap_or(true)
+        {
+            self.set_local_decision(self.current_decision());
+            tx.transaction_pool_update(
+                &self.transaction_id,
+                Some(is_ready),
+                Some(self.current_decision()),
+                Some(&self.evidence),
+                None,
+                None,
+            )?;
         }
         Ok(())
     }
@@ -738,6 +776,7 @@ mod tests {
                 transaction_id: TransactionId::new([0; 32]),
                 original_decision: Decision::Commit,
                 evidence: Default::default(),
+                remote_evidence: None,
                 transaction_fee: fee,
                 leader_fee: None,
                 stage: TransactionPoolStage::New,
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
index ce6301dbeb..3bed503a35 100644
--- a/dan_layer/storage/src/consensus_models/transaction_pool_status_update.rs
+++ b/dan_layer/storage/src/consensus_models/transaction_pool_status_update.rs
@@ -35,6 +35,10 @@ impl TransactionPoolStatusUpdate {
         &self.evidence
     }
 
+    pub fn evidence_mut(&mut self) -> &mut Evidence {
+        &mut self.evidence
+    }
+
     pub fn is_ready(&self) -> bool {
         self.is_ready
     }
diff --git a/dan_layer/storage/src/global/backend_adapter.rs b/dan_layer/storage/src/global/backend_adapter.rs
index 53cbb8f8d7..dd28ea8267 100644
--- a/dan_layer/storage/src/global/backend_adapter.rs
+++ b/dan_layer/storage/src/global/backend_adapter.rs
@@ -27,7 +27,6 @@ use tari_common_types::types::{FixedHash, PublicKey};
 use tari_dan_common_types::{
     committee::Committee,
     hashing::ValidatorNodeBalancedMerkleTree,
-    shard::Shard,
     Epoch,
     NodeAddressable,
     ShardGroup,
@@ -147,7 +146,7 @@ pub trait GlobalDbAdapter: AtomicDb + Send + Sync + Clone {
         tx: &mut Self::DbTransaction<'_>,
         epoch: Epoch,
         shard_group: ShardGroup,
-    ) -> Result<HashMap<Shard, Committee<Self::Addr>>, Self::Error>;
+    ) -> Result<HashMap<ShardGroup, Committee<Self::Addr>>, Self::Error>;
 
     fn validator_nodes_get_committees_for_epoch(
         &self,
diff --git a/dan_layer/storage/src/global/validator_node_db.rs b/dan_layer/storage/src/global/validator_node_db.rs
index 00bcd3522f..5ddcf001c9 100644
--- a/dan_layer/storage/src/global/validator_node_db.rs
+++ b/dan_layer/storage/src/global/validator_node_db.rs
@@ -23,7 +23,7 @@
 use std::collections::HashMap;
 
 use tari_common_types::types::PublicKey;
-use tari_dan_common_types::{committee::Committee, shard::Shard, Epoch, ShardGroup, SubstateAddress};
+use tari_dan_common_types::{committee::Committee, Epoch, ShardGroup, SubstateAddress};
 
 use crate::global::{models::ValidatorNode, GlobalDbAdapter};
 
@@ -116,7 +116,7 @@ impl<'a, 'tx, TGlobalDbAdapter: GlobalDbAdapter> ValidatorNodeDb<'a, 'tx, TGloba
         &mut self,
         epoch: Epoch,
         shard_group: ShardGroup,
-    ) -> Result<HashMap<Shard, Committee<TGlobalDbAdapter::Addr>>, TGlobalDbAdapter::Error> {
+    ) -> Result<HashMap<ShardGroup, Committee<TGlobalDbAdapter::Addr>>, TGlobalDbAdapter::Error> {
         self.backend
             .validator_nodes_get_for_shard_group(self.tx, epoch, shard_group)
             .map_err(TGlobalDbAdapter::Error::into)
diff --git a/dan_layer/storage/src/state_store/mod.rs b/dan_layer/storage/src/state_store/mod.rs
index 0d54114aef..916af22cf0 100644
--- a/dan_layer/storage/src/state_store/mod.rs
+++ b/dan_layer/storage/src/state_store/mod.rs
@@ -27,6 +27,7 @@ use crate::{
         Decision,
         EpochCheckpoint,
         Evidence,
+        ForeignParkedProposal,
         ForeignProposal,
         ForeignReceiveCounters,
         ForeignSendCounters,
@@ -381,7 +382,9 @@ pub trait StateStoreWriteTransaction {
     fn transaction_pool_update(
         &mut self,
         transaction_id: &TransactionId,
+        is_ready: Option<bool>,
         local_decision: Option<Decision>,
+        local_evidence: Option<&Evidence>,
         remote_decision: Option<Decision>,
         remote_evidence: Option<&Evidence>,
     ) -> Result<(), StorageError>;
@@ -397,6 +400,8 @@ pub trait StateStoreWriteTransaction {
         tx_ids: I,
     ) -> Result<(), StorageError>;
 
+    // -------------------------------- Missing Transactions -------------------------------- //
+
     fn missing_transactions_insert<
         'a,
         IMissing: IntoIterator<Item = &'a TransactionId>,
@@ -414,6 +419,19 @@ pub trait StateStoreWriteTransaction {
         transaction_id: &TransactionId,
     ) -> Result<Option<Block>, StorageError>;
 
+    fn foreign_parked_blocks_insert(&mut self, park_block: &ForeignParkedProposal) -> Result<(), StorageError>;
+
+    fn foreign_parked_blocks_insert_missing_transactions<'a, I: IntoIterator<Item = &'a TransactionId>>(
+        &mut self,
+        park_block_id: &BlockId,
+        missing_transaction_ids: I,
+    ) -> Result<(), StorageError>;
+
+    fn foreign_parked_blocks_remove_all_by_transaction(
+        &mut self,
+        transaction_id: &TransactionId,
+    ) -> Result<Vec<ForeignParkedProposal>, StorageError>;
+
     // -------------------------------- Votes -------------------------------- //
     fn votes_insert(&mut self, vote: &Vote) -> Result<(), StorageError>;
 
@@ -429,7 +447,7 @@ pub trait StateStoreWriteTransaction {
         transaction_ids: Peekable<I>,
     ) -> Result<(), StorageError>;
 
-    fn substates_create(&mut self, substate: SubstateRecord) -> Result<(), StorageError>;
+    fn substates_create(&mut self, substate: &SubstateRecord) -> Result<(), StorageError>;
     fn substates_down(
         &mut self,
         versioned_substate_id: VersionedSubstateId,
@@ -443,7 +461,7 @@ pub trait StateStoreWriteTransaction {
     // -------------------------------- Foreign pledges -------------------------------- //
 
     #[allow(clippy::mutable_key_type)]
-    fn foreign_substate_pledges_insert(
+    fn foreign_substate_pledges_save(
         &mut self,
         transaction_id: TransactionId,
         shard_group: ShardGroup,
diff --git a/dan_layer/storage_sqlite/src/global/backend_adapter.rs b/dan_layer/storage_sqlite/src/global/backend_adapter.rs
index 11c3e2bbbd..38b0df5c70 100644
--- a/dan_layer/storage_sqlite/src/global/backend_adapter.rs
+++ b/dan_layer/storage_sqlite/src/global/backend_adapter.rs
@@ -33,6 +33,7 @@ use diesel::{
     sql_types::{BigInt, Bigint},
     ExpressionMethods,
     JoinOnDsl,
+    NullableExpressionMethods,
     OptionalExtension,
     QueryDsl,
     RunQueryDsl,
@@ -44,7 +45,6 @@ use tari_common_types::types::{FixedHash, PublicKey};
 use tari_dan_common_types::{
     committee::Committee,
     hashing::ValidatorNodeBalancedMerkleTree,
-    shard::Shard,
     Epoch,
     NodeAddressable,
     ShardGroup,
@@ -70,6 +70,7 @@ use crate::{
     error::SqliteStorageError,
     global::{
         models::{
+            DbCommittee,
             MetadataModel,
             NewBaseLayerBlockInfo,
             NewEpoch,
@@ -630,57 +631,39 @@ impl<TAddr: NodeAddressable> GlobalDbAdapter for SqliteGlobalDbAdapter<TAddr> {
         tx: &mut Self::DbTransaction<'_>,
         epoch: Epoch,
         shard_group: ShardGroup,
-    ) -> Result<HashMap<Shard, Committee<Self::Addr>>, Self::Error> {
+    ) -> Result<HashMap<ShardGroup, Committee<Self::Addr>>, Self::Error> {
         use crate::global::schema::{committees, validator_nodes};
-        // let mut shards = shard_group
-        //     .shard_iter()
-        //     .map(|b| (b, Committee::empty()))
-        //     .collect::<HashMap<_, _>>();
 
         let mut committees = HashMap::with_capacity(shard_group.len());
-        for shard in shard_group.shard_iter() {
-            let validators = validator_nodes::table
-                .left_join(committees::table.on(committees::validator_node_id.eq(validator_nodes::id)))
-                .select(validator_nodes::all_columns)
-                .filter(committees::epoch.eq(epoch.as_u64() as i64))
-                .filter(committees::shard_start.le(shard.as_u32() as i32))
-                .filter(committees::shard_end.ge(shard.as_u32() as i32))
-                .get_results::<DbValidatorNode>(tx.connection())
-                .map_err(|source| SqliteStorageError::DieselError {
-                    source,
-                    operation: "validator_nodes_get_by_buckets".to_string(),
-                })?;
-
-            committees.insert(
-                shard,
-                validators
-                    .into_iter()
-                    .map(|validator| {
-                        Ok::<_, SqliteStorageError>((
-                            DbValidatorNode::try_parse_address(&validator.address)?,
-                            PublicKey::from_canonical_bytes(&validator.public_key).map_err(|_| {
-                                SqliteStorageError::MalformedDbData(format!(
-                                    "Invalid public key in validator node record id={}",
-                                    validator.id
-                                ))
-                            })?,
-                        ))
-                    })
-                    .collect::<Result<_, _>>()?,
-            );
-
-            // for validator in validators {
-            //     committee.members.push((
-            //         DbValidatorNode::try_parse_address(&validator.address)?,
-            //         PublicKey::from_canonical_bytes(&validator.public_key).map_err(|_| {
-            //             SqliteStorageError::MalformedDbData(format!(
-            //                 "Invalid public key in validator node record id={}",
-            //                 validator.id
-            //             ))
-            //         })?,
-            //     ));
-            // }
+        let validators = validator_nodes::table
+            .left_join(committees::table.on(committees::validator_node_id.eq(validator_nodes::id)))
+            .select((validator_nodes::all_columns, committees::all_columns.nullable()))
+            .filter(committees::epoch.eq(epoch.as_u64() as i64))
+            .filter(committees::shard_start.le(shard_group.start().as_u32() as i32))
+            .filter(committees::shard_end.ge(shard_group.end().as_u32() as i32))
+            .get_results::<(DbValidatorNode, Option<DbCommittee>)>(tx.connection())
+            .map_err(|source| SqliteStorageError::DieselError {
+                source,
+                operation: "validator_nodes_get_by_buckets".to_string(),
+            })?;
+
+        for (vn, committee) in validators {
+            let committee = committee.unwrap();
+            let validators = committees
+                .entry(committee.as_shard_group())
+                .or_insert_with(|| Committee::empty());
+
+            validators.members.push((
+                DbValidatorNode::try_parse_address(&vn.address)?,
+                PublicKey::from_canonical_bytes(&vn.public_key).map_err(|_| {
+                    SqliteStorageError::MalformedDbData(format!(
+                        "Invalid public key in validator node record id={}",
+                        vn.id
+                    ))
+                })?,
+            ));
         }
+
         Ok(committees)
     }
 
diff --git a/dan_layer/storage_sqlite/src/global/models/committee.rs b/dan_layer/storage_sqlite/src/global/models/committee.rs
index aac035da28..e302930bb2 100644
--- a/dan_layer/storage_sqlite/src/global/models/committee.rs
+++ b/dan_layer/storage_sqlite/src/global/models/committee.rs
@@ -20,15 +20,9 @@
 //  WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
 //  USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-use tari_common_types::types::PublicKey;
-use tari_dan_common_types::{shard::Shard, Epoch, NodeAddressable, SubstateAddress};
-use tari_dan_storage::global::models::ValidatorNode;
-use tari_utilities::ByteArray;
+use tari_dan_common_types::ShardGroup;
 
-use crate::{
-    error::SqliteStorageError,
-    global::{schema::*, serialization::deserialize_json},
-};
+use crate::global::schema::*;
 
 #[derive(Queryable, Identifiable)]
 #[diesel(table_name = committees)]
@@ -36,6 +30,12 @@ pub struct DbCommittee {
     pub id: i32,
     pub validator_node_id: i32,
     pub epoch: i64,
-    pub bucket: i64,
+    pub shard_start: i32,
+    pub shard_end: i32,
 }
 
+impl DbCommittee {
+    pub fn as_shard_group(&self) -> ShardGroup {
+        ShardGroup::new(self.shard_start as u32, self.shard_end as u32)
+    }
+}
diff --git a/dan_layer/storage_sqlite/src/global/models/mod.rs b/dan_layer/storage_sqlite/src/global/models/mod.rs
index af061925dd..4c8b8e6850 100644
--- a/dan_layer/storage_sqlite/src/global/models/mod.rs
+++ b/dan_layer/storage_sqlite/src/global/models/mod.rs
@@ -36,5 +36,9 @@ pub use base_layer_block_info::*;
 mod validator_node;
 pub use validator_node::*;
 
+mod committee;
+pub use committee::*;
+
 mod bmt;
+
 pub use bmt::*;
diff --git a/dan_layer/storage_sqlite/tests/global_db.rs b/dan_layer/storage_sqlite/tests/global_db.rs
index bd12cb7c3e..cbfd682892 100644
--- a/dan_layer/storage_sqlite/tests/global_db.rs
+++ b/dan_layer/storage_sqlite/tests/global_db.rs
@@ -5,7 +5,7 @@ use diesel::{Connection, SqliteConnection};
 use rand::rngs::OsRng;
 use tari_common_types::types::{FixedHash, PublicKey};
 use tari_crypto::keys::PublicKey as _;
-use tari_dan_common_types::{shard::Shard, Epoch, PeerAddress, ShardGroup, SubstateAddress};
+use tari_dan_common_types::{Epoch, PeerAddress, ShardGroup, SubstateAddress};
 use tari_dan_storage::global::{GlobalDb, ValidatorNodeDb};
 use tari_dan_storage_sqlite::global::SqliteGlobalDbAdapter;
 use tari_utilities::ByteArray;
@@ -103,5 +103,5 @@ fn change_committee_shard_group() {
     let vns = validator_nodes
         .get_committees_for_shard_group(Epoch(3), ShardGroup::new(4, 5))
         .unwrap();
-    assert_eq!(vns.get(&Shard::from(4)).unwrap().len(), 2);
+    assert_eq!(vns.get(&ShardGroup::new(4, 5)).unwrap().len(), 2);
 }
diff --git a/dan_layer/transaction/src/transaction.rs b/dan_layer/transaction/src/transaction.rs
index 43bba1a011..0fb46750ad 100644
--- a/dan_layer/transaction/src/transaction.rs
+++ b/dan_layer/transaction/src/transaction.rs
@@ -7,7 +7,7 @@ use indexmap::IndexSet;
 use serde::{Deserialize, Serialize};
 use tari_common_types::types::PublicKey;
 use tari_crypto::ristretto::RistrettoSecretKey;
-use tari_dan_common_types::{Epoch, SubstateAddress};
+use tari_dan_common_types::Epoch;
 use tari_engine_types::{
     hashing::{hasher32, EngineHashDomainLabel},
     indexed_value::{IndexedValue, IndexedValueError},
@@ -118,13 +118,6 @@ impl Transaction {
         &self.transaction.inputs
     }
 
-    fn input_addresses_iter(&self) -> impl Iterator<Item = SubstateAddress> + '_ {
-        self.transaction
-            .inputs
-            .iter()
-            .filter_map(|i: &SubstateRequirement| i.to_substate_address())
-    }
-
     /// Returns (fee instructions, instructions)
     pub fn into_instructions(self) -> (Vec<Instruction>, Vec<Instruction>) {
         (self.transaction.fee_instructions, self.transaction.instructions)
@@ -162,18 +155,10 @@ impl Transaction {
         self.all_inputs_substate_ids_iter().count()
     }
 
-    pub fn versioned_input_addresses_iter(&self) -> impl Iterator<Item = SubstateAddress> + '_ {
-        self.input_addresses_iter().chain(self.filled_input_addresses_iter())
-    }
-
     pub fn filled_inputs(&self) -> &IndexSet<VersionedSubstateId> {
         &self.filled_inputs
     }
 
-    fn filled_input_addresses_iter(&self) -> impl Iterator<Item = SubstateAddress> + '_ {
-        self.filled_inputs.iter().map(|i| i.to_substate_address())
-    }
-
     pub fn filled_inputs_mut(&mut self) -> &mut IndexSet<VersionedSubstateId> {
         &mut self.filled_inputs
     }
diff --git a/dan_layer/transaction/src/transaction_id.rs b/dan_layer/transaction/src/transaction_id.rs
index e229155892..a48dfb7679 100644
--- a/dan_layer/transaction/src/transaction_id.rs
+++ b/dan_layer/transaction/src/transaction_id.rs
@@ -10,6 +10,7 @@ use serde::{Deserialize, Serialize};
 use tari_common_types::types::FixedHashSizeError;
 use tari_crypto::tari_utilities::hex::{from_hex, Hex};
 use tari_engine_types::{serde_with, transaction_receipt::TransactionReceiptAddress};
+use tari_template_lib::Hash;
 
 #[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Deserialize, Serialize, Default)]
 #[serde(transparent)]
@@ -88,3 +89,9 @@ impl From<[u8; 32]> for TransactionId {
         Self::new(id)
     }
 }
+
+impl From<TransactionId> for Hash {
+    fn from(id: TransactionId) -> Self {
+        Hash::from(id.id)
+    }
+}