diff --git a/Cargo.lock b/Cargo.lock
index 9981c2869..453abe61f 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -9951,6 +9951,7 @@ dependencies = [
  "hex",
  "indexmap 2.6.0",
  "lazy_static",
+ "log",
  "rand",
  "serde",
  "serde_json",
@@ -10599,8 +10600,10 @@ version = "0.7.0"
 dependencies = [
  "borsh",
  "indexmap 2.6.0",
+ "log",
  "rand",
  "serde",
+ "tari_bor",
  "tari_common_types",
  "tari_crypto",
  "tari_dan_common_types",
diff --git a/applications/tari_dan_app_utilities/src/transaction_executor.rs b/applications/tari_dan_app_utilities/src/transaction_executor.rs
index b3e257e7b..08acbb153 100644
--- a/applications/tari_dan_app_utilities/src/transaction_executor.rs
+++ b/applications/tari_dan_app_utilities/src/transaction_executor.rs
@@ -117,7 +117,9 @@ where TTemplateProvider: TemplateProvider<Template = LoadedTemplate>
         let initial_ownership_proofs = transaction
             .signatures()
             .iter()
-            .map(|sig| public_key_to_fungible_address(sig.public_key()))
+            .map(|p| p.public_key())
+            .chain(Some(transaction.seal_signature().public_key()).filter(|_| transaction.is_seal_signer_authorized()))
+            .map(public_key_to_fungible_address)
             .collect();
         let auth_params = AuthParams {
             initial_ownership_proofs,
diff --git a/applications/tari_dan_wallet_cli/src/command/transaction.rs b/applications/tari_dan_wallet_cli/src/command/transaction.rs
index 0d53eb86b..3ba013fe5 100644
--- a/applications/tari_dan_wallet_cli/src/command/transaction.rs
+++ b/applications/tari_dan_wallet_cli/src/command/transaction.rs
@@ -317,8 +317,7 @@ async fn handle_submit_manifest(
                     component_address: fee_account.address.as_component_address().unwrap(),
                     method: "pay_fee".to_string(),
                     args: args![Amount::try_from(common.max_fee.unwrap_or(1000))?],
-                }])
-                .collect(),
+                }]),
         )
         .with_instructions(instructions.instructions)
         .with_inputs(common.inputs)
@@ -472,12 +471,12 @@ fn summarize_transaction(transaction: &UnsignedTransaction) {
     }
     println!();
     println!("🌟 Submitting fee instructions:");
-    for instruction in &transaction.fee_instructions {
+    for instruction in transaction.fee_instructions() {
         println!("- {}", instruction);
     }
     println!();
     println!("🌟 Submitting instructions:");
-    for instruction in &transaction.instructions {
+    for instruction in transaction.instructions() {
         println!("- {}", instruction);
     }
     println!();
diff --git a/applications/tari_dan_wallet_daemon/build.rs b/applications/tari_dan_wallet_daemon/build.rs
index 3c0446f92..53ddd15f9 100644
--- a/applications/tari_dan_wallet_daemon/build.rs
+++ b/applications/tari_dan_wallet_daemon/build.rs
@@ -29,9 +29,12 @@ fn exit_on_ci() {
 }
 
 const BUILD: &[(&str, &[&str])] = &[
-    ("../../bindings", &["ci"]),
+    ("../../bindings", &["install", "--omit=dev"]),
     ("../../bindings", &["run", "tsc"]),
-    ("../../clients/javascript/wallet_daemon_client", &["ci"]),
+    ("../../clients/javascript/wallet_daemon_client", &[
+        "install",
+        "--omit=dev",
+    ]),
     ("../../clients/javascript/wallet_daemon_client", &["run", "build"]),
     ("../tari_dan_wallet_web_ui", &["run", "build"]),
 ];
@@ -48,8 +51,12 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     let npm = if cfg!(windows) { "npm.cmd" } else { "npm" };
 
     for (target, args) in BUILD {
-        if let Err(error) = Command::new(npm).arg("ci").current_dir(target).status() {
-            println!("cargo:warning='npm ci' error : {:?}", error);
+        if let Err(error) = Command::new(npm)
+            .args(["install", "--omit=dev"])
+            .current_dir(target)
+            .status()
+        {
+            println!("cargo:warning='npm install' error : {:?}", error);
             exit_on_ci();
             break;
         }
diff --git a/applications/tari_dan_wallet_daemon/src/handlers/accounts.rs b/applications/tari_dan_wallet_daemon/src/handlers/accounts.rs
index fc83fbc1d..346b88809 100644
--- a/applications/tari_dan_wallet_daemon/src/handlers/accounts.rs
+++ b/applications/tari_dan_wallet_daemon/src/handlers/accounts.rs
@@ -126,8 +126,7 @@ pub async fn handle_create(
         .fee_transaction_pay_from_component(default_account.address.as_component_address().unwrap(), max_fee)
         .create_account(owner_pk.clone())
         .with_inputs(inputs)
-        .sign(&signing_key.key)
-        .build();
+        .build_and_seal(&signing_key.key);
 
     let mut events = context.notifier().subscribe();
     let tx_id = context
@@ -227,8 +226,7 @@ pub async fn handle_invoke(
         .fee_transaction_pay_from_component(account_address, req.max_fee.unwrap_or(DEFAULT_FEE))
         .call_method(account_address, &req.method, req.args)
         .with_inputs(inputs)
-        .sign(&signing_key.key)
-        .build();
+        .build_and_seal(&signing_key.key);
 
     let mut events = context.notifier().subscribe();
     let tx_id = context
@@ -433,7 +431,7 @@ pub async fn handle_reveal_funds(
             .into_iter()
             .map(|addr| SubstateRequirement::new(addr.substate_id.clone(), Some(addr.version)));
 
-        let transaction = builder.with_inputs(inputs).sign(&account_key.key).build();
+        let transaction = builder.with_inputs(inputs).build_and_seal(&account_key.key);
 
         sdk.confidential_outputs_api()
             .proofs_set_transaction_hash(proof_id, *transaction.id())?;
@@ -698,8 +696,7 @@ async fn finish_claiming<T: WalletStore>(
     let transaction = Transaction::builder()
         .with_fee_instructions(instructions)
         .with_inputs(inputs)
-        .sign(&account_secret_key.key)
-        .build();
+        .build_and_seal(&account_secret_key.key);
     let is_first_account = accounts_api.count()? == 0;
     let mut events = context.notifier().subscribe();
     let tx_id = context
@@ -948,8 +945,7 @@ pub async fn handle_transfer(
         .with_fee_instructions(fee_instructions)
         .with_instructions(instructions)
         .with_inputs(vec![resource_substate_address])
-        .sign(&account_secret_key.key)
-        .build();
+        .build_and_seal(&account_secret_key.key);
 
     let required_inputs = inputs.into_iter().map(Into::into).collect();
     // If dry run we can return the result immediately
diff --git a/applications/tari_dan_wallet_daemon/src/handlers/nfts.rs b/applications/tari_dan_wallet_daemon/src/handlers/nfts.rs
index 05f92b651..64bc08771 100644
--- a/applications/tari_dan_wallet_daemon/src/handlers/nfts.rs
+++ b/applications/tari_dan_wallet_daemon/src/handlers/nfts.rs
@@ -210,8 +210,7 @@ async fn mint_account_nft(
     let transaction = Transaction::builder()
         .fee_transaction_pay_from_component(account.address.as_component_address().unwrap(), fee)
         .with_instructions(instructions)
-        .sign(owner_sk)
-        .build();
+        .build_and_seal(owner_sk);
 
     let mut events = context.notifier().subscribe();
     let tx_id = context
@@ -254,8 +253,7 @@ async fn create_account_nft(
         .fee_transaction_pay_from_component(account.address.as_component_address().unwrap(), fee)
         .call_function(ACCOUNT_NFT_TEMPLATE_ADDRESS, "create", args![owner_token,])
         .with_inputs(inputs)
-        .sign(owner_sk)
-        .build();
+        .build_and_seal(owner_sk);
 
     let tx_id = sdk
         .transaction_api()
diff --git a/applications/tari_dan_wallet_daemon/src/handlers/transaction.rs b/applications/tari_dan_wallet_daemon/src/handlers/transaction.rs
index 6b0adc7e4..881eef52c 100644
--- a/applications/tari_dan_wallet_daemon/src/handlers/transaction.rs
+++ b/applications/tari_dan_wallet_daemon/src/handlers/transaction.rs
@@ -1,20 +1,22 @@
 //   Copyright 2023 The Tari Project
 //   SPDX-License-Identifier: BSD-3-Clause
-use std::{collections::HashSet, time::Duration};
+use std::time::Duration;
 
 use anyhow::anyhow;
+use axum_jrpc::error::{JsonRpcError, JsonRpcErrorReason};
 use futures::{future, future::Either};
 use log::*;
 use tari_dan_app_utilities::json_encoding;
 use tari_dan_common_types::{optional::Optional, Epoch, SubstateRequirement};
 use tari_dan_wallet_sdk::apis::{jwt::JrpcPermission, key_manager};
-use tari_engine_types::{indexed_value::IndexedValue, instruction::Instruction, substate::SubstateId};
-use tari_template_lib::{args, args::Arg, models::Amount};
+use tari_template_lib::{args, models::Amount};
 use tari_transaction::Transaction;
 use tari_wallet_daemon_client::types::{
     AccountGetRequest,
     AccountGetResponse,
     CallInstructionRequest,
+    PublishTemplateRequest,
+    PublishTemplateResponse,
     TransactionGetAllRequest,
     TransactionGetAllResponse,
     TransactionGetRequest,
@@ -31,7 +33,10 @@ use tari_wallet_daemon_client::types::{
 use tokio::time;
 
 use super::{accounts, context::HandlerContext};
-use crate::{handlers::HandlerError, services::WalletEvent};
+use crate::{
+    handlers::{helpers::get_account_or_default, HandlerError},
+    services::WalletEvent,
+};
 
 const LOG_TARGET: &str = "tari::dan::wallet_daemon::handlers::transaction";
 
@@ -100,8 +105,7 @@ pub async fn handle_submit(
     let autofill_inputs = req.autofill_inputs;
     let detected_inputs = if req.detect_inputs {
         // If we are not overriding inputs, we will use inputs that we know about in the local substate id db
-        let mut substates = get_referenced_substate_addresses(&req.transaction.instructions)?;
-        substates.extend(get_referenced_substate_addresses(&req.transaction.fee_instructions)?);
+        let substates = req.transaction.to_referenced_substates()?;
         let substates = substates.into_iter().collect::<Vec<_>>();
         let loaded_substates = sdk.substate_api().locate_dependent_substates(&substates).await?;
         loaded_substates
@@ -129,8 +133,7 @@ pub async fn handle_submit(
     let transaction = Transaction::builder()
         .with_unsigned_transaction(req.transaction)
         .with_inputs(detected_inputs)
-        .sign(&key.key)
-        .build();
+        .build_and_seal(&key.key);
 
     for input in transaction.inputs() {
         debug!(target: LOG_TARGET, "Input: {}", input)
@@ -173,8 +176,7 @@ pub async fn handle_submit_dry_run(
     let autofill_inputs = req.autofill_inputs;
     let detected_inputs = if req.detect_inputs {
         // If we are not overriding inputs, we will use inputs that we know about in the local substate id db
-        let mut substates = get_referenced_substate_addresses(&req.transaction.instructions)?;
-        substates.extend(get_referenced_substate_addresses(&req.transaction.fee_instructions)?);
+        let substates = req.transaction.to_referenced_substates()?;
         let substates = substates.into_iter().collect::<Vec<_>>();
         sdk.substate_api().locate_dependent_substates(&substates).await?
     } else {
@@ -184,8 +186,7 @@ pub async fn handle_submit_dry_run(
     let transaction = Transaction::builder()
         .with_unsigned_transaction(req.transaction)
         .with_inputs(detected_inputs)
-        .sign(&key.key)
-        .build();
+        .build_and_seal(&key.key);
 
     for proof_id in req.proof_ids {
         // update the proofs table with the corresponding transaction hash
@@ -200,7 +201,7 @@ pub async fn handle_submit_dry_run(
     );
     let exec_result = context
         .transaction_service()
-        .submit_dry_run_transaction(transaction, autofill_inputs.clone())
+        .submit_dry_run_transaction(transaction, autofill_inputs)
         .await?;
 
     let json_result = json_encoding::encode_finalize_result_into_json(&exec_result.finalize)?;
@@ -371,33 +372,56 @@ pub async fn handle_wait_result(
     }
 }
 
-fn get_referenced_substate_addresses(instructions: &[Instruction]) -> anyhow::Result<HashSet<SubstateId>> {
-    let mut substates = HashSet::new();
-    for instruction in instructions {
-        match instruction {
-            Instruction::CallMethod {
-                component_address,
-                args,
-                ..
-            } => {
-                substates.insert(SubstateId::Component(*component_address));
-                for arg in args {
-                    if let Arg::Literal(bytes) = arg {
-                        let val = IndexedValue::from_raw(bytes)?;
-                        substates.extend(val.referenced_substates());
-                    }
-                }
-            },
-            Instruction::CallFunction { args, .. } => {
-                for arg in args {
-                    if let Arg::Literal(bytes) = arg {
-                        let val = IndexedValue::from_raw(bytes)?;
-                        substates.extend(val.referenced_substates());
-                    }
-                }
-            },
-            _ => {},
+pub async fn handle_publish_template(
+    context: &HandlerContext,
+    token: Option<String>,
+    req: PublishTemplateRequest,
+) -> Result<PublishTemplateResponse, anyhow::Error> {
+    let sdk = context.wallet_sdk();
+
+    let fee_account = get_account_or_default(req.fee_account, &sdk.accounts_api())?;
+
+    let transaction = Transaction::builder()
+        .fee_transaction_pay_from_component(
+            fee_account.address.as_component_address().unwrap(),
+            req.max_fee.try_into()?,
+        )
+        .publish_template(req.binary)
+        .build_unsigned_transaction();
+
+    if req.dry_run {
+        let request = TransactionSubmitDryRunRequest {
+            transaction,
+            signing_key_index: Some(fee_account.key_index),
+            autofill_inputs: vec![],
+            detect_inputs: req.detect_inputs,
+            proof_ids: vec![],
+        };
+        let resp = handle_submit_dry_run(context, token, request).await?;
+        if let Some(reject) = resp.result.finalize.full_reject() {
+            return Err(JsonRpcError::new(
+                JsonRpcErrorReason::ApplicationError(5),
+                format!("Dry-run transaction rejected: {reject}"),
+                serde_json::Value::Null,
+            )
+            .into());
         }
+        return Ok(PublishTemplateResponse {
+            transaction_id: resp.transaction_id,
+            dry_run_fee: Some(resp.result.finalize.fee_receipt.total_fees_charged()),
+        });
     }
-    Ok(substates)
+    let request = TransactionSubmitRequest {
+        transaction,
+        signing_key_index: Some(fee_account.key_index),
+        autofill_inputs: vec![],
+        detect_inputs: req.detect_inputs,
+        detect_inputs_use_unversioned: true,
+        proof_ids: vec![],
+    };
+    let resp = handle_submit(context, token, request).await?;
+    Ok(PublishTemplateResponse {
+        transaction_id: resp.transaction_id,
+        dry_run_fee: None,
+    })
 }
diff --git a/applications/tari_dan_wallet_daemon/src/handlers/validator.rs b/applications/tari_dan_wallet_daemon/src/handlers/validator.rs
index 9a29c3a64..31e62c2ea 100644
--- a/applications/tari_dan_wallet_daemon/src/handlers/validator.rs
+++ b/applications/tari_dan_wallet_daemon/src/handlers/validator.rs
@@ -76,8 +76,7 @@ pub async fn handle_claim_validator_fees(
 
     let transaction = Transaction::builder()
         .with_fee_instructions(fee_instructions)
-        .sign(&account_secret_key.key)
-        .build();
+        .build_and_seal(&account_secret_key.key);
 
     // send the transaction
     let required_inputs = inputs.into_iter().map(Into::into).collect();
diff --git a/applications/tari_dan_wallet_daemon/src/jrpc_server.rs b/applications/tari_dan_wallet_daemon/src/jrpc_server.rs
index d81291a1d..103c00717 100644
--- a/applications/tari_dan_wallet_daemon/src/jrpc_server.rs
+++ b/applications/tari_dan_wallet_daemon/src/jrpc_server.rs
@@ -4,7 +4,7 @@
 use std::{net::SocketAddr, sync::Arc};
 
 use axum::{
-    extract::Extension,
+    extract::{DefaultBodyLimit, Extension},
     http::{Request, StatusCode},
     middleware::Next,
     response::Response,
@@ -73,6 +73,8 @@ pub fn spawn_listener(
         .layer(Extension((preferred_address,signaling_server_address)))
         .layer(Extension(Arc::new(shutdown_signal.clone())))
         .layer(CorsLayer::permissive())
+        // Limit the body size to 5MB to allow for wasm uploads
+        .layer(DefaultBodyLimit::max(5*1024*1024))
         .layer(axum::middleware::from_fn(extract_token));
 
     let server = axum::Server::try_bind(&preferred_address)?;
@@ -124,6 +126,7 @@ async fn handler(
             "submit_instruction" => call_handler(context, value, token, transaction::handle_submit_instruction).await,
             "submit" => call_handler(context, value, token, transaction::handle_submit).await,
             "submit_dry_run" => call_handler(context, value, token, transaction::handle_submit_dry_run).await,
+            "publish_template" => call_handler(context, value, token, transaction::handle_publish_template).await,
             "get" => call_handler(context, value, token, transaction::handle_get).await,
             "get_result" => call_handler(context, value, token, transaction::handle_get_result).await,
             "wait_result" => call_handler(context, value, token, transaction::handle_wait_result).await,
diff --git a/applications/tari_dan_wallet_web_ui/package-lock.json b/applications/tari_dan_wallet_web_ui/package-lock.json
index 60199f031..339f0cbdb 100644
--- a/applications/tari_dan_wallet_web_ui/package-lock.json
+++ b/applications/tari_dan_wallet_web_ui/package-lock.json
@@ -24,6 +24,7 @@
         "react-dom": "^18.2.0",
         "react-icons": "^4.9.0",
         "react-router-dom": "^6.9.0",
+        "use-file-picker": "^2.1.2",
         "use-react-router-breadcrumbs": "^4.0.1",
         "zustand": "^4.4.1",
         "zustand-persist": "^0.1.6"
@@ -40,7 +41,7 @@
     },
     "../../bindings": {
       "name": "@tari-project/typescript-bindings",
-      "version": "1.2.0",
+      "version": "1.3.0",
       "license": "ISC",
       "devDependencies": {
         "shx": "^0.3.4",
@@ -48,10 +49,11 @@
       }
     },
     "../../clients/javascript/wallet_daemon_client": {
+      "name": "@tari-project/wallet_jrpc_client",
       "version": "1.2.0",
       "license": "ISC",
       "dependencies": {
-        "@tari-project/typescript-bindings": "1.2.0"
+        "@tari-project/typescript-bindings": "1.3.0"
       },
       "devDependencies": {
         "typescript": "^5.3.3"
@@ -2848,6 +2850,22 @@
       "resolved": "https://registry.npmjs.org/file-saver/-/file-saver-2.0.5.tgz",
       "integrity": "sha512-P9bmyZ3h/PRG+Nzga+rbdI4OEpNDzAVyy74uVO9ATgzLK6VtAsYybF/+TOCvrc0MO793d6+42lLyZTw7/ArVzA=="
     },
+    "node_modules/file-selector": {
+      "version": "0.2.4",
+      "resolved": "https://registry.npmjs.org/file-selector/-/file-selector-0.2.4.tgz",
+      "integrity": "sha512-ZDsQNbrv6qRi1YTDOEWzf5J2KjZ9KMI1Q2SGeTkCJmNNW25Jg4TW4UMcmoqcg4WrAyKRcpBXdbWRxkfrOzVRbA==",
+      "dependencies": {
+        "tslib": "^2.0.3"
+      },
+      "engines": {
+        "node": ">= 10"
+      }
+    },
+    "node_modules/file-selector/node_modules/tslib": {
+      "version": "2.8.1",
+      "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz",
+      "integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w=="
+    },
     "node_modules/fill-range": {
       "version": "7.1.1",
       "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.1.1.tgz",
@@ -4249,6 +4267,20 @@
       "resolved": "https://registry.npmjs.org/uqr/-/uqr-0.1.2.tgz",
       "integrity": "sha512-MJu7ypHq6QasgF5YRTjqscSzQp/W11zoUk6kvmlH+fmWEs63Y0Eib13hYFwAzagRJcVY8WVnlV+eBDUGMJ5IbA=="
     },
+    "node_modules/use-file-picker": {
+      "version": "2.1.2",
+      "resolved": "https://registry.npmjs.org/use-file-picker/-/use-file-picker-2.1.2.tgz",
+      "integrity": "sha512-ZEIzRi1wXeIXDWr5i55gRBVER8rTkSGskDUY94bciTTAZJHlBnOTRLL/LDYjgz6d+US3yELHnRvtBhLxFGtB0A==",
+      "dependencies": {
+        "file-selector": "0.2.4"
+      },
+      "engines": {
+        "node": ">=12"
+      },
+      "peerDependencies": {
+        "react": ">=16"
+      }
+    },
     "node_modules/use-react-router-breadcrumbs": {
       "version": "4.0.1",
       "resolved": "https://registry.npmjs.org/use-react-router-breadcrumbs/-/use-react-router-breadcrumbs-4.0.1.tgz",
diff --git a/applications/tari_dan_wallet_web_ui/package.json b/applications/tari_dan_wallet_web_ui/package.json
index cc3303939..f1db0dd5d 100644
--- a/applications/tari_dan_wallet_web_ui/package.json
+++ b/applications/tari_dan_wallet_web_ui/package.json
@@ -26,6 +26,7 @@
     "react-icons": "^4.9.0",
     "react-router-dom": "^6.9.0",
     "use-react-router-breadcrumbs": "^4.0.1",
+    "use-file-picker": "^2.1.2",
     "zustand": "^4.4.1",
     "zustand-persist": "^0.1.6"
   },
diff --git a/applications/tari_dan_wallet_web_ui/src/api/hooks/useAccounts.tsx b/applications/tari_dan_wallet_web_ui/src/api/hooks/useAccounts.tsx
index c63510bb3..8f3dd7d28 100644
--- a/applications/tari_dan_wallet_web_ui/src/api/hooks/useAccounts.tsx
+++ b/applications/tari_dan_wallet_web_ui/src/api/hooks/useAccounts.tsx
@@ -31,6 +31,7 @@ import {
   accountsList,
   accountsTransfer,
   nftList,
+  transactionsPublishTemplate,
 } from "../../utils/json_rpc";
 import { apiError } from "../helpers/types";
 import queryClient from "../queryClient";
diff --git a/applications/tari_dan_wallet_web_ui/src/api/hooks/useTransactions.tsx b/applications/tari_dan_wallet_web_ui/src/api/hooks/useTransactions.tsx
index aae0f6304..c2a6cbd86 100644
--- a/applications/tari_dan_wallet_web_ui/src/api/hooks/useTransactions.tsx
+++ b/applications/tari_dan_wallet_web_ui/src/api/hooks/useTransactions.tsx
@@ -20,13 +20,18 @@
 //  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.
 
-import { useQuery } from "@tanstack/react-query";
-import { transactionsGet, transactionsGetAll } from "../../utils/json_rpc";
+import { useMutation, useQuery } from "@tanstack/react-query";
+import { transactionsGet, transactionsGetAll, transactionsPublishTemplate } from "../../utils/json_rpc";
 import { apiError } from "../helpers/types";
+import queryClient from "../queryClient";
 
-import type { TransactionStatus } from "@tari-project/typescript-bindings";
+import type {
+  ComponentAddressOrName,
+  PublishTemplateRequest,
+  TransactionStatus,
+} from "@tari-project/typescript-bindings";
 
-const useTransactionDetails = (hash: string) => {
+export const useTransactionDetails = (hash: string) => {
   return useQuery({
     queryKey: ["transaction_details"],
     queryFn: () => {
@@ -38,7 +43,7 @@ const useTransactionDetails = (hash: string) => {
   });
 };
 
-const useGetAllTransactions = (status: TransactionStatus | null, component: string | null) => {
+export const useGetAllTransactions = (status: TransactionStatus | null, component: string | null) => {
   return useQuery({
     queryKey: ["transactions"],
     queryFn: () => transactionsGetAll({ status: status, component: component }),
@@ -50,4 +55,14 @@ const useGetAllTransactions = (status: TransactionStatus | null, component: stri
   });
 };
 
-export { useTransactionDetails, useGetAllTransactions };
+export const usePublishTemplate = () => {
+  return useMutation(transactionsPublishTemplate, {
+    onError: (error: apiError) => {
+      console.error(error);
+    },
+    onSettled: () => {
+      queryClient.invalidateQueries(["transactions"]);
+      queryClient.invalidateQueries(["accounts_balances"]);
+    },
+  });
+};
diff --git a/applications/tari_dan_wallet_web_ui/src/routes/AssetVault/Components/ActionMenu.tsx b/applications/tari_dan_wallet_web_ui/src/routes/AssetVault/Components/ActionMenu.tsx
index c89bedf60..7412c6fb0 100644
--- a/applications/tari_dan_wallet_web_ui/src/routes/AssetVault/Components/ActionMenu.tsx
+++ b/applications/tari_dan_wallet_web_ui/src/routes/AssetVault/Components/ActionMenu.tsx
@@ -28,6 +28,7 @@ import ClaimBurn from "./ClaimBurn";
 import useAccountStore from "../../../store/accountStore";
 import SendMoney from "./SendMoney";
 import ClaimFees from "./ClaimFees";
+import PublishTemplate from "./PublishTemplate";
 
 function ActionMenu() {
   const { mutate } = useAccountsCreateFreeTestCoins();
@@ -37,7 +38,7 @@ function ActionMenu() {
   const onClaimFreeCoins = () => {
     mutate({
       accountName: accountName,
-      amount: 200000,
+      amount: 1_000_000_000,
       fee: 1000,
     });
   };
@@ -56,6 +57,7 @@ function ActionMenu() {
         Claim Free Testnet Coins
       </Button>
       <ClaimBurn />
+      <PublishTemplate />
     </Box>
   );
 }
diff --git a/applications/tari_dan_wallet_web_ui/src/routes/AssetVault/Components/PublishTemplate.tsx b/applications/tari_dan_wallet_web_ui/src/routes/AssetVault/Components/PublishTemplate.tsx
new file mode 100644
index 000000000..7d8dfb88f
--- /dev/null
+++ b/applications/tari_dan_wallet_web_ui/src/routes/AssetVault/Components/PublishTemplate.tsx
@@ -0,0 +1,274 @@
+//  Copyright 2022. The Tari Project
+//
+//  Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
+//  following conditions are met:
+//
+//  1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following
+//  disclaimer.
+//
+//  2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the
+//  following disclaimer in the documentation and/or other materials provided with the distribution.
+//
+//  3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote
+//  products derived from this software without specific prior written permission.
+//
+//  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+//  INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+//  DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+//  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+//  SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+//  WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+//  USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+import { useEffect, useState } from "react";
+import { Form } from "react-router-dom";
+import Button from "@mui/material/Button";
+import TextField from "@mui/material/TextField";
+import Dialog from "@mui/material/Dialog";
+import DialogContent from "@mui/material/DialogContent";
+import DialogTitle from "@mui/material/DialogTitle";
+import Box from "@mui/material/Box";
+import { useAccountsList } from "../../../api/hooks/useAccounts";
+import { useTheme } from "@mui/material/styles";
+import useAccountStore from "../../../store/accountStore";
+import Select from "@mui/material/Select";
+import { SelectChangeEvent } from "@mui/material/Select/Select";
+import MenuItem from "@mui/material/MenuItem";
+import { useFilePicker } from "use-file-picker";
+import { ResourceAddress, ResourceType } from "@tari-project/typescript-bindings";
+import InputLabel from "@mui/material/InputLabel";
+import { usePublishTemplate } from "../../../api/hooks/useTransactions";
+import { Input } from "@mui/material";
+import { FileAmountLimitValidator, FileSizeValidator, FileTypeValidator } from "use-file-picker/validators";
+import { FileContent } from "use-file-picker/types";
+import { base64FromArrayBuffer } from "../../../utils/helpers";
+
+export default function PublishTemplate() {
+  const [open, setOpen] = useState(false);
+
+  return (
+    <>
+      <Button variant="outlined" onClick={() => setOpen(true)}>
+        Publish Template
+      </Button>
+      <PublishTemplateDialog
+        open={open}
+        handleClose={() => setOpen(false)}
+        onSendComplete={() => setOpen(false)}
+        resource_type="Confidential"
+      />
+    </>
+  );
+}
+
+export interface DialogProps {
+  open: boolean;
+  resource_address?: ResourceAddress;
+  resource_type?: ResourceType;
+  onSendComplete?: () => void;
+  handleClose: () => void;
+}
+
+interface FormState {
+  binary: ArrayBuffer | null;
+  file: FileContent<ArrayBuffer> | null;
+  account: string | null;
+  maxFee: number | null;
+}
+
+function PublishTemplateDialog(props: DialogProps) {
+  const INITIAL_VALUES = {
+    binary: null,
+    file: null,
+    account: null,
+    maxFee: null,
+  };
+  const [disabled, setDisabled] = useState(false);
+  const [formState, setFormState] = useState<FormState>(INITIAL_VALUES);
+  const [validity, setValidity] = useState<object>({
+    file: false,
+    account: false,
+    maxFee: true,
+  });
+  const [allValid, setAllValid] = useState(false);
+
+  const { accountName, setPopup } = useAccountStore();
+
+  const theme = useTheme();
+
+  let { data: accountsResp } = useAccountsList(0, 1000);
+  let accounts = accountsResp?.accounts;
+
+  const { mutateAsync: publishTemplate } = usePublishTemplate();
+
+  function setFormValue(e: React.ChangeEvent<HTMLInputElement>) {
+    setFormState({
+      ...formState,
+      [e.target.name]: e.target.value,
+    });
+    if (validity[e.target.name as keyof object] !== undefined) {
+      setValidity({
+        ...validity,
+        [e.target.name]: e.target.validity.valid,
+      });
+    }
+  }
+
+  function setSelectFormValue(e: SelectChangeEvent<unknown>) {
+    setFormState({
+      ...formState,
+      [e.target.name]: e.target.value,
+    });
+  }
+
+  const onSubmit = async () => {
+    if (accountName) {
+      setDisabled(true);
+      const isDryRun = !formState.maxFee;
+      publishTemplate({
+        fee_account: { Name: accountName },
+        binary: base64FromArrayBuffer(formState.binary!),
+        max_fee: isDryRun ? 1_000_000 : formState.maxFee || 0,
+        detect_inputs: true,
+        dry_run: isDryRun,
+      })
+        .then((resp) => {
+          if (isDryRun) {
+            setFormState({ ...formState, maxFee: resp.dry_run_fee! });
+          } else {
+            setFormState(INITIAL_VALUES);
+            props.onSendComplete?.();
+            setPopup({ title: "Publish template transaction submitted", error: false });
+          }
+        })
+        .catch((e) => {
+          setPopup({ title: "Publish failed", error: true, message: e.message });
+        })
+        .finally(() => {
+          setDisabled(false);
+        });
+    }
+  };
+
+  const handleClose = () => {
+    props.handleClose?.();
+  };
+
+  useEffect(() => {
+    setAllValid(Object.values(validity).every((v) => v));
+  }, [validity]);
+
+  const {
+    openFilePicker,
+    errors: fpErrors,
+    loading: fpLoading,
+  } = useFilePicker({
+    multiple: false,
+    readAs: "ArrayBuffer",
+    validators: [
+      new FileAmountLimitValidator({ max: 1 }),
+      new FileTypeValidator(["wasm"]),
+      new FileSizeValidator({ maxFileSize: 5 * 1024 * 1024 }),
+    ],
+    onFilesSuccessfullySelected: ({ filesContent }) => {
+      setFormState({
+        ...formState,
+        binary: filesContent[0].content,
+        file: filesContent[0],
+      });
+      setValidity({
+        ...validity,
+        file: true,
+      });
+    },
+    onFilesRejected: () => {
+      setValidity({
+        ...validity,
+        file: false,
+      });
+    },
+  });
+
+  useEffect(() => {
+    let account = accounts?.find((a) => a.account.is_default)?.account.name || null;
+    if (account) {
+      setFormState({ ...INITIAL_VALUES, account });
+      setValidity({ ...validity, account: true });
+    }
+  }, [accounts]);
+
+  return (
+    <Dialog open={props.open} onClose={handleClose}>
+      <DialogTitle>Send {props.resource_address}</DialogTitle>
+      <DialogContent className="dialog-content">
+        <Form onSubmit={onSubmit} className="flex-container-vertical" style={{ paddingTop: theme.spacing(1) }}>
+          {accounts && (
+            <>
+              <InputLabel id="select-account">Account</InputLabel>
+              <Select
+                id="select-account"
+                name="account"
+                disabled={disabled}
+                displayEmpty
+                value={formState.account || accounts.find((a) => a.account.is_default) || ""}
+                onChange={setSelectFormValue}
+                variant="outlined"
+              >
+                {accounts.map((account, i) => (
+                  <MenuItem key={i} value={account.account.name!}>
+                    {account.account.name} {account.account.is_default ? "(default)" : ""}
+                  </MenuItem>
+                ))}
+              </Select>
+            </>
+          )}
+          <Box
+            className="flex-container"
+            style={{
+              justifyContent: "flex-start",
+            }}
+          >
+            <Button
+              variant="outlined"
+              onClick={(e) => {
+                e.preventDefault();
+                openFilePicker();
+              }}
+              disabled={disabled || fpLoading}
+            >
+              Select WASM
+            </Button>
+            {formState.file && (
+              <p style={{ color: "blue" }}>
+                {formState.file.name} {formState.binary?.byteLength} bytes
+              </p>
+            )}
+            {fpErrors[0] && <p style={{ color: "red" }}>{fpErrors[0].name}</p>}
+          </Box>
+          <TextField
+            name="fee"
+            label="Fee"
+            value={formState.maxFee}
+            placeholder="Enter max fee"
+            onChange={setFormValue}
+            disabled={disabled}
+            style={{ flexGrow: 1 }}
+          />
+          <Box
+            className="flex-container"
+            style={{
+              justifyContent: "flex-end",
+            }}
+          >
+            <Button variant="outlined" onClick={handleClose} disabled={disabled}>
+              Cancel
+            </Button>
+            <Button variant="contained" type="submit" disabled={disabled || fpLoading || !allValid}>
+              {formState.maxFee ? "Publish" : "Estimate fee"}
+            </Button>
+          </Box>
+        </Form>
+      </DialogContent>
+    </Dialog>
+  );
+}
diff --git a/applications/tari_dan_wallet_web_ui/src/routes/Onboarding/Onboarding.tsx b/applications/tari_dan_wallet_web_ui/src/routes/Onboarding/Onboarding.tsx
index 379c9b930..bf1ed102e 100644
--- a/applications/tari_dan_wallet_web_ui/src/routes/Onboarding/Onboarding.tsx
+++ b/applications/tari_dan_wallet_web_ui/src/routes/Onboarding/Onboarding.tsx
@@ -45,7 +45,7 @@ function Onboarding() {
     mutate(
       {
         accountName: accountFormState.accountName,
-        amount: 200000,
+        amount: 1_000_000_000,
         fee: 1000,
       },
       {
diff --git a/applications/tari_dan_wallet_web_ui/src/routes/Transactions/TransactionDetails.tsx b/applications/tari_dan_wallet_web_ui/src/routes/Transactions/TransactionDetails.tsx
index 6c2561db6..858fbfeb7 100644
--- a/applications/tari_dan_wallet_web_ui/src/routes/Transactions/TransactionDetails.tsx
+++ b/applications/tari_dan_wallet_web_ui/src/routes/Transactions/TransactionDetails.tsx
@@ -129,7 +129,10 @@ export default function TransactionDetails() {
       }
     };
 
-    const transaction = data.transaction.V1;
+    const transaction_id = data.transaction.V1?.id;
+    const seal_signature = data.transaction.V1?.seal_signature;
+    const transaction_body = data.transaction.V1?.body;
+    const transaction = transaction_body?.transaction;
 
     if (data.status === "Rejected" || data.status === "InvalidTransaction") {
       return (
@@ -139,7 +142,7 @@ export default function TransactionDetails() {
               <TableBody>
                 <TableRow>
                   <TableCell>Transaction Hash</TableCell>
-                  <DataTableCell>{transaction.id}</DataTableCell>
+                  <DataTableCell>{transaction_id}</DataTableCell>
                 </TableRow>
                 <TableRow>
                   <TableCell>Timestamp</TableCell>
@@ -179,7 +182,7 @@ export default function TransactionDetails() {
                 <TableBody>
                   <TableRow>
                     <TableCell>Transaction Hash</TableCell>
-                    <DataTableCell>{transaction.id}</DataTableCell>
+                    <DataTableCell>{transaction_id}</DataTableCell>
                   </TableRow>
                   <TableRow>
                     <TableCell>Timestamp</TableCell>
@@ -314,11 +317,18 @@ export default function TransactionDetails() {
               <Typography>Signers</Typography>
             </AccordionSummary>
             <AccordionDetails>
-              {transaction?.signatures?.length ? (
+              {transaction_body?.signatures?.length ? (
                 <TableContainer>
                   <Table>
                     <TableBody>
-                      {transaction.signatures.map((item: TransactionSignature, i: number) => {
+                      {seal_signature ? (
+                        <TableRow key={-1}>
+                          <DataTableCell>{seal_signature.public_key}</DataTableCell>
+                        </TableRow>
+                      ) : (
+                        <></>
+                      )}
+                      {transaction_body.signatures.map((item: TransactionSignature, i: number) => {
                         return (
                           <TableRow key={i}>
                             <DataTableCell>{item.public_key}</DataTableCell>
diff --git a/applications/tari_dan_wallet_web_ui/src/routes/Wallet/Components/Accounts.tsx b/applications/tari_dan_wallet_web_ui/src/routes/Wallet/Components/Accounts.tsx
index 8d4d090fe..5845843ac 100644
--- a/applications/tari_dan_wallet_web_ui/src/routes/Wallet/Components/Accounts.tsx
+++ b/applications/tari_dan_wallet_web_ui/src/routes/Wallet/Components/Accounts.tsx
@@ -161,7 +161,7 @@ function Accounts() {
   const onClaimFreeCoins = async () => {
     await mutateCreateFeeTestCoins({
       accountName: "TestAccount",
-      amount: 200000,
+      amount: 1_000_000_000,
       fee: 1000,
     });
   };
diff --git a/applications/tari_dan_wallet_web_ui/src/utils/helpers.tsx b/applications/tari_dan_wallet_web_ui/src/utils/helpers.tsx
index cc745b037..fb29eee28 100644
--- a/applications/tari_dan_wallet_web_ui/src/utils/helpers.tsx
+++ b/applications/tari_dan_wallet_web_ui/src/utils/helpers.tsx
@@ -133,3 +133,67 @@ export function handleChangeRowsPerPage(
   setRowsPerPage(parseInt(event.target.value, 10));
   setPage(0);
 }
+
+// Converts an ArrayBuffer directly to base64, without any intermediate 'convert to string then
+// use window.btoa' step. According to my tests, this appears to be a faster approach:
+// http://jsperf.com/encoding-xhr-image-data/5
+
+/*
+MIT LICENSE
+Copyright 2011 Jon Leighton
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/
+
+export function base64FromArrayBuffer(arrayBuffer: ArrayBuffer) {
+  let base64 = "";
+  const ENCODINGS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+
+  const bytes = new Uint8Array(arrayBuffer);
+  const byteLength = bytes.byteLength;
+  const byteRemainder = byteLength % 3;
+  const mainLength = byteLength - byteRemainder;
+
+  let a, b, c, d;
+  let chunk;
+
+  // Main loop deals with bytes in chunks of 3
+  for (let i = 0; i < mainLength; i = i + 3) {
+    // Combine the three bytes into a single integer
+    chunk = (bytes[i] << 16) | (bytes[i + 1] << 8) | bytes[i + 2];
+
+    // Use bitmasks to extract 6-bit segments from the triplet
+    a = (chunk & 16515072) >> 18; // 16515072 = (2^6 - 1) << 18
+    b = (chunk & 258048) >> 12; // 258048   = (2^6 - 1) << 12
+    c = (chunk & 4032) >> 6; // 4032     = (2^6 - 1) << 6
+    d = chunk & 63; // 63       = 2^6 - 1
+
+    // Convert the raw binary segments to the appropriate ASCII encoding
+    base64 += ENCODINGS[a] + ENCODINGS[b] + ENCODINGS[c] + ENCODINGS[d];
+  }
+
+  // Deal with the remaining bytes and padding
+  if (byteRemainder == 1) {
+    chunk = bytes[mainLength];
+
+    a = (chunk & 252) >> 2; // 252 = (2^6 - 1) << 2
+
+    // Set the 4 least significant bits to zero
+    b = (chunk & 3) << 4; // 3   = 2^2 - 1
+
+    base64 += ENCODINGS[a] + ENCODINGS[b] + "==";
+  } else if (byteRemainder == 2) {
+    chunk = (bytes[mainLength] << 8) | bytes[mainLength + 1];
+
+    a = (chunk & 64512) >> 10; // 64512 = (2^6 - 1) << 10
+    b = (chunk & 1008) >> 4; // 1008  = (2^6 - 1) << 4
+
+    // Set the 2 least significant bits to zero
+    c = (chunk & 15) << 2; // 15    = 2^4 - 1
+
+    base64 += ENCODINGS[a] + ENCODINGS[b] + ENCODINGS[c] + "=";
+  }
+
+  return base64;
+}
diff --git a/applications/tari_dan_wallet_web_ui/src/utils/json_rpc.tsx b/applications/tari_dan_wallet_web_ui/src/utils/json_rpc.tsx
index 81f291e08..055910741 100644
--- a/applications/tari_dan_wallet_web_ui/src/utils/json_rpc.tsx
+++ b/applications/tari_dan_wallet_web_ui/src/utils/json_rpc.tsx
@@ -43,6 +43,8 @@ import type {
   ConfidentialTransferResponse,
   ConfidentialViewVaultBalanceRequest,
   ConfidentialViewVaultBalanceResponse,
+  PublishTemplateRequest,
+  PublishTemplateResponse,
   KeysCreateRequest,
   KeysCreateResponse,
   KeysListRequest,
@@ -172,6 +174,8 @@ export const transactionsWaitResult = (request: TransactionWaitResultRequest): P
 export const transactionsGetAll = (request: TransactionGetAllRequest): Promise<TransactionGetAllResponse> =>
   client().then((c) => c.transactionsList(request));
 
+export const transactionsPublishTemplate = (request: PublishTemplateRequest): Promise<PublishTemplateResponse> =>
+  client().then((c) => c.publishTemplate(request));
 // accounts
 
 export const accountsRevealFunds = (request: RevealFundsRequest): Promise<RevealFundsResponse> =>
@@ -180,6 +184,7 @@ export const accountsClaimBurn = (request: ClaimBurnRequest): Promise<ClaimBurnR
   client().then((c) => c.accountsClaimBurn(request));
 export const accountsCreate = (request: AccountsCreateRequest): Promise<AccountsCreateResponse> =>
   client().then((c) => c.accountsCreate(request));
+
 export const accountsList = (request: AccountsListRequest): Promise<AccountsListResponse> =>
   client().then((c) => c.accountsList(request));
 export const accountsGetBalances = (request: AccountsGetBalancesRequest): Promise<AccountsGetBalancesResponse> =>
diff --git a/applications/tari_indexer/src/json_rpc/server.rs b/applications/tari_indexer/src/json_rpc/server.rs
index 6ff39f556..5a0ce6393 100644
--- a/applications/tari_indexer/src/json_rpc/server.rs
+++ b/applications/tari_indexer/src/json_rpc/server.rs
@@ -22,7 +22,12 @@
 
 use std::{net::SocketAddr, sync::Arc};
 
-use axum::{extract::Extension, middleware, routing::post, Router};
+use axum::{
+    extract::{DefaultBodyLimit, Extension},
+    middleware,
+    routing::post,
+    Router,
+};
 use axum_jrpc::{JrpcResult, JsonRpcExtractor};
 use log::*;
 use tower_http::cors::CorsLayer;
@@ -37,6 +42,8 @@ pub fn spawn_json_rpc(preferred_address: SocketAddr, handlers: JsonRpcHandlers)
         .route("/json_rpc", post(handler))
         .layer(middleware::from_fn(logger::middleware_fn))
         .layer(Extension(Arc::new(handlers)))
+        // Limit the body size to 5MB to allow for large transactions (wasm uploads)
+        .layer(DefaultBodyLimit::max(5*1024*1024))
         .layer(CorsLayer::permissive());
 
     let server = axum::Server::try_bind(&preferred_address).or_else(|_| {
diff --git a/applications/tari_swarm_daemon/webui/src/routes/Main.tsx b/applications/tari_swarm_daemon/webui/src/routes/Main.tsx
index 339d584f4..4ca7dede2 100644
--- a/applications/tari_swarm_daemon/webui/src/routes/Main.tsx
+++ b/applications/tari_swarm_daemon/webui/src/routes/Main.tsx
@@ -78,10 +78,14 @@ function ExtraInfoVN({ name, url, addTxToPool, autoRefresh, state, horizontal }:
     jsonRpc2(url, "get_tx_pool").then((resp) => {
       setPool(resp.tx_pool);
       addTxToPool(resp.tx_pool.filter((tx: any) => Boolean(tx?.transaction)).map((tx: any) => tx.transaction.id).sort());
+    }).catch((resp) => {
+      console.error("err", resp);
     });
     jsonRpc2(url, "get_identity").then((resp) => {
       setPublicKey(resp.public_key);
       setPeerId(resp.peer_id);
+    }).catch((resp) => {
+      console.error("err", resp);
     });
     let missing_tx = new Set();
     for (const k in state) {
@@ -113,6 +117,8 @@ function ExtraInfoVN({ name, url, addTxToPool, autoRefresh, state, horizontal }:
       if (JSON.stringify(newState) != JSON.stringify(missingTxStates)) {
         setMissingTxStates(newState);
       }
+    }).catch((resp) => {
+      console.error("all settled err", resp);
     });
     // for (let tx of missing_tx) {
     //   jsonRpc2(url, "get_transaction", [tx]).then((resp) => {
diff --git a/applications/tari_validator_node/src/dan_node.rs b/applications/tari_validator_node/src/dan_node.rs
index 270fdb1a5..1a2d2b631 100644
--- a/applications/tari_validator_node/src/dan_node.rs
+++ b/applications/tari_validator_node/src/dan_node.rs
@@ -23,14 +23,7 @@
 use log::*;
 use tari_consensus::hotstuff::HotstuffEvent;
 use tari_dan_app_utilities::template_manager::interface::TemplateExecutable;
-use tari_dan_storage::{
-    consensus_models::{Block, Decision},
-    StateStore,
-};
-use tari_engine_types::{
-    commit_result::TransactionResult,
-    substate::{SubstateId, SubstateValue},
-};
+use tari_dan_storage::{consensus_models::Block, StateStore};
 use tari_epoch_manager::{EpochManagerEvent, EpochManagerReader};
 use tari_networking::NetworkingService;
 use tari_shutdown::ShutdownSignal;
@@ -63,11 +56,11 @@ impl DanNode {
                      break;
                 },
 
-                Ok(event) = hotstuff_events.recv() => if let Err(err) = self.handle_hotstuff_event(event).await{
+                Ok(event) = hotstuff_events.recv() => if let Err(err) = self.handle_hotstuff_event(event).await {
                     error!(target: LOG_TARGET, "Error handling hotstuff event: {}", err);
                 },
 
-                Ok(event) = epoch_manager_events.recv() => if let Err(err) = self.handle_epoch_manager_event(event).await{
+                Ok(event) = epoch_manager_events.recv() => if let Err(err) = self.handle_epoch_manager_event(event).await {
                     error!(target: LOG_TARGET, "Error handling epoch manager event: {}", err);
                 },
 
@@ -97,49 +90,54 @@ impl DanNode {
     /// from the given block.
     async fn handle_template_publishes(&self, block: &Block) -> Result<(), anyhow::Error> {
         // add wasm templates to template manager if available in any of the new block's transactions
-        let templates = self
+        let transactions = self
             .services
             .state_store
-            .with_read_tx(|tx| block.get_transactions(tx))?
+            .with_read_tx(|tx| block.get_committing_transactions(tx))?;
+
+        let templates = transactions
             .into_iter()
-            .filter(|record| matches!(record.final_decision, Some(Decision::Commit)))
             .filter_map(|record| {
                 let result = record.execution_result?;
-                let TransactionResult::Accept(diff) = result.finalize.result else {
-                    return None;
-                };
-                let tx_signature = record.transaction.signatures().first()?;
-                let signer_pub_key = tx_signature.public_key().clone();
+                let diff = result.finalize.result.into_accept()?;
+                let signer_pub_key = record.transaction.seal_signature().public_key().clone();
                 Some((signer_pub_key, diff))
             })
             .flat_map(|(signer_pub_key, diff)| {
-                let mut templates = vec![];
-                for (substate_id, substate) in diff.into_up_iter() {
-                    if let SubstateId::Template(template_address) = substate_id {
-                        let template_address_hash = template_address.as_hash();
-                        if let SubstateValue::Template(template) = substate.into_substate_value() {
-                            templates.push((
-                                signer_pub_key.clone(),
-                                template_address_hash,
-                                TemplateExecutable::CompiledWasm(template.binary),
-                            ));
-                        }
-                    }
-                }
-                templates
+                diff.into_up_iter().flat_map(move |(substate_id, substate)| {
+                    let template_address = substate_id.as_template()?;
+                    let template = substate.into_substate_value().into_template()?;
+                    Some((
+                        signer_pub_key.clone(),
+                        template_address.as_hash(),
+                        TemplateExecutable::CompiledWasm(template.binary),
+                    ))
+                })
             });
 
         // adding templates to template manager
         let mut template_counter = 0;
         for (author_pub_key, template_address, template) in templates {
-            self.services
+            info!(
+                target: LOG_TARGET,
+                "📰 Adding template {} from block {}",
+                template_address,
+                block
+            );
+            if let Err(err) = self
+                .services
                 .template_manager
                 .add_template(author_pub_key, template_address, template, None)
-                .await?;
+                .await
+            {
+                error!(target: LOG_TARGET, "🚨Failed to add template: {}", err);
+            }
             template_counter += 1;
         }
 
-        if template_counter > 0 {
+        if template_counter == 0 {
+            debug!(target: LOG_TARGET, "No new templates published in block {}", block);
+        } else {
             info!(target: LOG_TARGET, "🏁 {} new template(s) have been persisted locally.", template_counter);
         }
 
@@ -157,8 +155,6 @@ impl DanNode {
 
         info!(target: LOG_TARGET, "🏁 Block {} committed", block);
 
-        self.handle_template_publishes(&block).await?;
-
         let committed_transactions = block
             .commands()
             .iter()
@@ -170,6 +166,8 @@ impl DanNode {
             return Ok(());
         }
 
+        self.handle_template_publishes(&block).await?;
+
         info!(target: LOG_TARGET, "🏁 Removing {} finalized transaction(s) from mempool", committed_transactions.len());
         if let Err(err) = self.services.mempool.remove_transactions(committed_transactions).await {
             error!(target: LOG_TARGET, "Failed to remove transaction from mempool: {}", err);
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 4c5c0cba0..d0a4d3c7a 100644
--- a/applications/tari_validator_node/src/p2p/services/mempool/service.rs
+++ b/applications/tari_validator_node/src/p2p/services/mempool/service.rs
@@ -259,11 +259,12 @@ where TValidator: Validator<Transaction, Context = (), Error = TransactionValida
 
         let local_committee_shard = self.epoch_manager.get_local_committee_info(current_epoch).await?;
         let is_input_shard = transaction.is_involved_inputs(&local_committee_shard);
-        let is_output_shard = local_committee_shard.includes_any_address(
-            // Known output shards
-            // This is to allow for the txreceipt output and indicates shard involvement.
-            iter::once(&tx_substate_address).chain(claim_shards.iter()),
-        );
+        let is_output_shard = transaction.is_global() ||
+            local_committee_shard.includes_any_address(
+                // Known output shards
+                // This is to allow for the txreceipt output and indicates shard involvement.
+                iter::once(&tx_substate_address).chain(claim_shards.iter()),
+            );
 
         if is_input_shard || is_output_shard {
             debug!(target: LOG_TARGET, "🎱 New transaction {} in mempool", transaction.id());
diff --git a/applications/tari_validator_node/src/transaction_validators/signature.rs b/applications/tari_validator_node/src/transaction_validators/signature.rs
index 81d107e53..8a2ae1852 100644
--- a/applications/tari_validator_node/src/transaction_validators/signature.rs
+++ b/applications/tari_validator_node/src/transaction_validators/signature.rs
@@ -16,13 +16,6 @@ impl Validator<Transaction> for TransactionSignatureValidator {
     type Error = TransactionValidationError;
 
     fn validate(&self, _context: &(), transaction: &Transaction) -> Result<(), TransactionValidationError> {
-        if transaction.signatures().is_empty() {
-            warn!(target: LOG_TARGET, "TransactionSignatureValidator - FAIL: No signatures");
-            return Err(TransactionValidationError::TransactionNotSigned {
-                transaction_id: *transaction.id(),
-            });
-        }
-
         if !transaction.verify_all_signatures() {
             warn!(target: LOG_TARGET, "TransactionSignatureValidator - FAIL: Invalid signature");
             return Err(TransactionValidationError::InvalidSignature);
diff --git a/applications/tari_validator_node_cli/src/command/transaction.rs b/applications/tari_validator_node_cli/src/command/transaction.rs
index b488251e8..1d641e1c9 100644
--- a/applications/tari_validator_node_cli/src/command/transaction.rs
+++ b/applications/tari_validator_node_cli/src/command/transaction.rs
@@ -240,8 +240,7 @@ pub async fn submit_transaction(
     let transaction = Transaction::builder()
         .with_instructions(instructions)
         .with_inputs(inputs)
-        .sign(&key.secret_key)
-        .build();
+        .build_and_seal(&key.secret_key);
 
     let request = SubmitTransactionRequest {
         transaction,
diff --git a/clients/javascript/wallet_daemon_client/package.json b/clients/javascript/wallet_daemon_client/package.json
index 8addf1cb0..ba831e9be 100644
--- a/clients/javascript/wallet_daemon_client/package.json
+++ b/clients/javascript/wallet_daemon_client/package.json
@@ -17,7 +17,7 @@
   "author": "",
   "license": "ISC",
   "dependencies": {
-    "@tari-project/typescript-bindings": "1.2.0"
+    "@tari-project/typescript-bindings": "1.3.0"
   },
   "devDependencies": {
     "typescript": "^5.3.3"
diff --git a/clients/javascript/wallet_daemon_client/src/index.ts b/clients/javascript/wallet_daemon_client/src/index.ts
index ef59327ee..ad65ebdfb 100644
--- a/clients/javascript/wallet_daemon_client/src/index.ts
+++ b/clients/javascript/wallet_daemon_client/src/index.ts
@@ -41,6 +41,8 @@ import {
   KeysSetActiveResponse,
   ListAccountNftRequest,
   ListAccountNftResponse,
+  PublishTemplateRequest,
+  PublishTemplateResponse,
   RevealFundsRequest,
   RevealFundsResponse,
   SettingsGetResponse,
@@ -122,6 +124,8 @@ export type {
   KeysSetActiveResponse,
   ListAccountNftRequest,
   ListAccountNftResponse,
+  PublishTemplateRequest,
+  PublishTemplateResponse,
   RevealFundsRequest,
   RevealFundsResponse,
   SettingsGetResponse,
@@ -253,6 +257,11 @@ export class WalletDaemonClient {
     return this.__invokeRpc("transactions.submit", params);
   }
 
+  public publishTemplate(params: PublishTemplateRequest): Promise<PublishTemplateResponse> {
+    return this.__invokeRpc("transactions.publish_template", params);
+  }
+
+
   public substatesGet(params: SubstatesGetRequest): Promise<SubstatesGetResponse> {
     return this.__invokeRpc("substates.get", params);
   }
diff --git a/clients/wallet_daemon_client/src/types.rs b/clients/wallet_daemon_client/src/types.rs
index 5763dcd4b..7a2558a4e 100644
--- a/clients/wallet_daemon_client/src/types.rs
+++ b/clients/wallet_daemon_client/src/types.rs
@@ -157,6 +157,38 @@ pub struct TransactionSubmitDryRunResponse {
     pub json_result: Vec<serde_json::Value>,
 }
 
+#[derive(Debug, Clone, Deserialize, Serialize)]
+#[cfg_attr(
+    feature = "ts",
+    derive(TS),
+    ts(export, export_to = "../../bindings/src/types/wallet-daemon-client/")
+)]
+pub struct PublishTemplateRequest {
+    #[cfg_attr(feature = "ts", ts(type = "string"))]
+    #[serde(with = "serde_with::base64")]
+    pub binary: Vec<u8>,
+    #[serde(deserialize_with = "opt_string_or_struct")]
+    pub fee_account: Option<ComponentAddressOrName>,
+    #[cfg_attr(feature = "ts", ts(type = "number"))]
+    pub max_fee: u64,
+    /// Attempt to infer inputs and their dependencies from instructions. If false, the provided transaction must
+    /// contain the required inputs.
+    pub detect_inputs: bool,
+    pub dry_run: bool,
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+#[cfg_attr(
+    feature = "ts",
+    derive(TS),
+    ts(export, export_to = "../../bindings/src/types/wallet-daemon-client/")
+)]
+pub struct PublishTemplateResponse {
+    #[cfg_attr(feature = "ts", ts(type = "string"))]
+    pub transaction_id: TransactionId,
+    pub dry_run_fee: Option<Amount>,
+}
+
 #[derive(Debug, Clone, Deserialize, Serialize)]
 #[cfg_attr(
     feature = "ts",
diff --git a/dan_layer/consensus/src/hotstuff/on_propose.rs b/dan_layer/consensus/src/hotstuff/on_propose.rs
index b365d7f1c..e670f6772 100644
--- a/dan_layer/consensus/src/hotstuff/on_propose.rs
+++ b/dan_layer/consensus/src/hotstuff/on_propose.rs
@@ -869,6 +869,7 @@ where TConsensusSpec: ConsensusSpec
             .iter()
             .filter(|o| {
                 o.substate_id().is_transaction_receipt() ||
+                    o.substate_id().is_published_template() ||
                     local_committee_info.includes_substate_address(&o.to_substate_address())
             })
             .map(|output| SubstateRequirementLockIntent::from(output.clone()));
diff --git a/dan_layer/consensus/src/hotstuff/transaction_manager/manager.rs b/dan_layer/consensus/src/hotstuff/transaction_manager/manager.rs
index 8c4b2ae58..d7dcf92e7 100644
--- a/dan_layer/consensus/src/hotstuff/transaction_manager/manager.rs
+++ b/dan_layer/consensus/src/hotstuff/transaction_manager/manager.rs
@@ -30,6 +30,7 @@ use tari_dan_storage::{
 };
 use tari_engine_types::{
     commit_result::RejectReason,
+    published_template::PublishedTemplateAddress,
     substate::Substate,
     transaction_receipt::TransactionReceiptAddress,
 };
@@ -164,6 +165,14 @@ impl<TStateStore: StateStore, TExecutor: BlockTransactionExecutor<TStateStore>>
             0,
         ));
 
+        for binary in transaction.transaction().publish_templates_iter() {
+            let author = transaction.transaction().seal_signature().public_key();
+            outputs.insert(VersionedSubstateId::new(
+                PublishedTemplateAddress::from_author_and_code(author, binary),
+                0,
+            ));
+        }
+
         let (local_versions, non_local_inputs) = match self.resolve_local_versions(
             store,
             local_committee_info,
diff --git a/dan_layer/consensus_tests/src/consensus.rs b/dan_layer/consensus_tests/src/consensus.rs
index 062c43b00..f5189bb14 100644
--- a/dan_layer/consensus_tests/src/consensus.rs
+++ b/dan_layer/consensus_tests/src/consensus.rs
@@ -478,8 +478,7 @@ async fn multishard_local_inputs_foreign_outputs() {
     let tx1 = build_transaction_from(
         Transaction::builder()
             .with_inputs(inputs.iter().cloned().map(|i| i.into()))
-            .sign(&PrivateKey::default())
-            .build(),
+            .build_and_seal(&PrivateKey::default()),
         Decision::Commit,
     );
     test.create_execution_at_destination_for_transaction(
@@ -541,8 +540,7 @@ async fn multishard_local_inputs_and_outputs_foreign_outputs() {
     let tx1 = build_transaction_from(
         Transaction::builder()
             .with_inputs(inputs_0.iter().chain(&inputs_1).cloned().map(|i| i.into()))
-            .sign(&PrivateKey::default())
-            .build(),
+            .build_and_seal(&PrivateKey::default()),
         Decision::Commit,
     );
     test.create_execution_at_destination_for_transaction(
@@ -616,8 +614,7 @@ async fn multishard_output_conflict_abort() {
     let inputs = test.create_substates_on_vns(TestVnDestination::All, 1);
     let tx = Transaction::builder()
         .with_inputs(inputs.iter().cloned().map(|i| i.into()))
-        .sign(&Default::default())
-        .build();
+        .build_and_seal(&Default::default());
     let tx2 = build_transaction_from(tx, Decision::Commit);
     assert_ne!(tx1.id(), tx2.id());
     test.create_execution_at_destination_for_transaction(
@@ -680,8 +677,7 @@ async fn single_shard_inputs_from_previous_outputs() {
 
     let tx2 = Transaction::builder()
         .with_inputs(prev_outputs.clone())
-        .sign(&Default::default())
-        .build();
+        .build_and_seal(&Default::default());
     let tx2 = build_transaction_from(tx2.clone(), Decision::Commit);
     test.create_execution_at_destination_for_transaction(
         TestVnDestination::All,
@@ -745,8 +741,7 @@ async fn multishard_inputs_from_previous_outputs() {
 
     let tx2 = Transaction::builder()
         .with_inputs(prev_outputs.clone())
-        .sign(&Default::default())
-        .build();
+        .build_and_seal(&Default::default());
     let tx2 = build_transaction_from(tx2.clone(), Decision::Commit);
     test.create_execution_at_destination_for_transaction(
         TestVnDestination::All,
@@ -799,14 +794,12 @@ async fn single_shard_input_conflict() {
 
     let tx1 = Transaction::builder()
         .add_input(substate_id.clone())
-        .sign(&Default::default())
-        .build();
+        .build_and_seal(&Default::default());
     let tx1 = TransactionRecord::new(tx1);
 
     let tx2 = Transaction::builder()
         .add_input(substate_id.clone())
-        .sign(&Default::default())
-        .build();
+        .build_and_seal(&Default::default());
     let tx2 = TransactionRecord::new(tx2);
 
     test.add_execution_at_destination(TestVnDestination::All, ExecuteSpec {
@@ -1048,8 +1041,7 @@ async fn single_shard_unversioned_inputs() {
         .map(|i| SubstateRequirement::new(i.substate_id.clone(), None));
     let tx = Transaction::builder()
         .with_inputs(unversioned_inputs)
-        .sign(&PrivateKey::default())
-        .build();
+        .build_and_seal(&PrivateKey::default());
     let tx = TransactionRecord::new(tx);
 
     test.send_transaction_to_destination(TestVnDestination::All, tx.clone())
@@ -1125,15 +1117,13 @@ async fn multi_shard_unversioned_input_conflict() {
     let tx1 = Transaction::builder()
         .add_input(SubstateRequirement::unversioned(id0.substate_id().clone()))
         .add_input(SubstateRequirement::unversioned(id1.substate_id().clone()))
-        .sign(&Default::default())
-        .build();
+        .build_and_seal(&Default::default());
     let tx1 = TransactionRecord::new(tx1);
 
     let tx2 = Transaction::builder()
         .add_input(SubstateRequirement::unversioned(id0.substate_id().clone()))
         .add_input(SubstateRequirement::unversioned(id1.substate_id().clone()))
-        .sign(&Default::default())
-        .build();
+        .build_and_seal(&Default::default());
     let tx2 = TransactionRecord::new(tx2);
 
     test.add_execution_at_destination(TestVnDestination::All, ExecuteSpec {
diff --git a/dan_layer/consensus_tests/src/support/transaction.rs b/dan_layer/consensus_tests/src/support/transaction.rs
index 9e784af5c..6263af0b3 100644
--- a/dan_layer/consensus_tests/src/support/transaction.rs
+++ b/dan_layer/consensus_tests/src/support/transaction.rs
@@ -134,8 +134,7 @@ pub fn build_transaction(decision: Decision, inputs: Vec<SubstateRequirement>) -
     let tx = Transaction::builder()
         .call_function(Default::default(), "foo", args![])
         .with_inputs(inputs)
-        .sign(&k)
-        .build();
+        .build_and_seal(&k);
     let mut tx = TransactionRecord::new(tx);
     if decision.is_abort() {
         tx.set_abort_reason(RejectReason::ExecutionFailure("Test aborted".to_string()));
diff --git a/dan_layer/engine/src/runtime/impl.rs b/dan_layer/engine/src/runtime/impl.rs
index 911b748ae..27fa2c88a 100644
--- a/dan_layer/engine/src/runtime/impl.rs
+++ b/dan_layer/engine/src/runtime/impl.rs
@@ -34,7 +34,6 @@ use tari_engine_types::{
     confidential::{get_commitment_factory, get_range_proof_service, ConfidentialClaim, ConfidentialOutput},
     entity_id_provider::EntityIdProvider,
     events::Event,
-    hashing::{hasher32, template_hasher32, EngineHashDomainLabel},
     indexed_value::IndexedValue,
     instruction_result::InstructionResult,
     lock::LockFlag,
@@ -2347,17 +2346,13 @@ impl<TTemplateProvider: TemplateProvider<Template = LoadedTemplate>> RuntimeInte
 
     fn publish_template(&self, template: Vec<u8>) -> Result<(), RuntimeError> {
         self.tracker.write_with(|state| {
-            let binary_hash = template_hasher32().chain(&template).result();
-            let template_address = PublishedTemplateAddress::from_hash(
-                hasher32(EngineHashDomainLabel::TemplateAddress)
-                    .chain(&self.transaction_signer_public_key)
-                    .chain(&binary_hash)
-                    .result(),
-            );
+            let template_address =
+                PublishedTemplateAddress::from_author_and_code(&self.transaction_signer_public_key, &template);
             state.new_substate(
                 template_address,
                 SubstateValue::Template(PublishedTemplate { binary: template }),
             )?;
+            // Mark template substate as owned by current call stack
             let scope_mut = state.current_call_scope_mut()?;
             scope_mut.move_node_to_owned(&template_address.into())?;
 
diff --git a/dan_layer/engine/src/transaction/processor.rs b/dan_layer/engine/src/transaction/processor.rs
index f6663c404..b15488319 100644
--- a/dan_layer/engine/src/transaction/processor.rs
+++ b/dan_layer/engine/src/transaction/processor.rs
@@ -164,16 +164,16 @@ impl<TTemplateProvider: TemplateProvider<Template = LoadedTemplate> + 'static> T
 
         let tracker = StateTracker::new(state_db, virtual_substates, initial_call_scope, transaction.hash());
 
-        // TODO: We'll have a "notarized" transaction that is signed by a single key. It signs a challenge incl. all the
-        // signatures of the transaction. We could define this signature as the "default" owner or we
-        // could remove the idea of a default owner (OwnedBySigner) entirely.
-        // For now the first signature in the list is used.
-        let transaction_signer_public_key = transaction
-            .signatures()
-            .first()
-            .map(|sig| sig.public_key().clone())
+        // TODO: If the seal signer is authorized we use this as the signer public key, if not we use the first
+        // signature as the "default" owner. This is due to limitations of the current transaction model.
+        // We could remove the idea of a default owner (OwnedBySigner) entirely.
+        let transaction_signer_public_key = Some(transaction.seal_signature())
+            .filter(|_| transaction.is_seal_signer_authorized())
+            .map(|s| s.public_key())
+            .or(transaction.signatures().first().map(|s| s.public_key()))
+            .cloned()
             .ok_or_else(|| TransactionError::InvariantError {
-                details: "Transaction must have at least one signature".to_string(),
+                details: "Transaction must have at least one authorized signature".to_string(),
             })?;
 
         let runtime_interface = RuntimeInterfaceImpl::initialize(
diff --git a/dan_layer/engine/tests/access_rules.rs b/dan_layer/engine/tests/access_rules.rs
index 5033a7c59..0a9af4950 100644
--- a/dan_layer/engine/tests/access_rules.rs
+++ b/dan_layer/engine/tests/access_rules.rs
@@ -65,8 +65,7 @@ mod component_access_rules {
                     // Badge recall rule
                     AccessRule::DenyAll,
                 ])
-                .sign(&owner1_key)
-                .build(),
+                .build_and_seal(&owner1_key),
             // Because we deny_all on deposits, we need to supply the owner proof to be able to deposit the initial
             // tokens into the new vaults
             vec![owner1_proof.clone()],
@@ -79,8 +78,7 @@ mod component_access_rules {
         test.execute_expect_success(
             Transaction::builder()
                 .call_method(component_address, "set_value", args![1])
-                .sign(&owner2_key)
-                .build(),
+                .build_and_seal(&owner2_key),
             vec![owner2_proof],
         );
 
@@ -89,8 +87,7 @@ mod component_access_rules {
         let reason = test.execute_expect_failure(
             Transaction::builder()
                 .call_method(component_address, "set_value", args![1])
-                .sign(&unauth_key)
-                .build(),
+                .build_and_seal(&unauth_key),
             vec![unauth_proof],
         );
 
@@ -122,8 +119,7 @@ mod component_access_rules {
                     // Badge recall rule
                     AccessRule::DenyAll
                 ])
-                .sign(&owner_key)
-                .build(),
+                .build_and_seal(&owner_key),
             vec![owner_proof.clone()],
         );
 
@@ -135,8 +131,7 @@ mod component_access_rules {
         let reason = test.execute_expect_failure(
             Transaction::builder()
                 .call_method(component_address, "set_value", args![1])
-                .sign(&user_key)
-                .build(),
+                .build_and_seal(&user_key),
             vec![user_proof.clone()],
         );
 
@@ -153,16 +148,14 @@ mod component_access_rules {
                         .add_method_rule("set_value", rule!(non_fungible(user_proof.clone())))
                         .default(AccessRule::DenyAll)
                 ])
-                .sign(&owner_key)
-                .build(),
+                .build_and_seal(&owner_key),
             vec![owner_proof],
         );
 
         test.execute_expect_success(
             Transaction::builder()
                 .call_method(component_address, "set_value", args![1])
-                .sign(&user_key)
-                .build(),
+                .build_and_seal(&user_key),
             vec![user_proof.clone()],
         );
 
@@ -171,8 +164,7 @@ mod component_access_rules {
                 .call_method(component_address, "set_component_access_rules", args![
                     ComponentAccessRules::new().default(AccessRule::AllowAll)
                 ])
-                .sign(&user_key)
-                .build(),
+                .build_and_seal(&user_key),
             vec![user_proof],
         );
     }
@@ -198,8 +190,7 @@ mod component_access_rules {
                     // Badge recall rule
                     AccessRule::DenyAll,
                 ])
-                .sign(&owner_key)
-                .build(),
+                .build_and_seal(&owner_key),
             vec![owner_proof.clone()],
         );
 
@@ -213,8 +204,7 @@ mod component_access_rules {
                 .call_method(component_address, "set_component_access_rules", args![
                     ComponentAccessRules::new().default(AccessRule::AllowAll)
                 ])
-                .sign(&owner_key)
-                .build(),
+                .build_and_seal(&owner_key),
             vec![owner_proof],
         );
 
@@ -252,8 +242,7 @@ mod resource_access_rules {
                     // Badge recall rule
                     AccessRule::DenyAll,
                 ])
-                .sign(&owner_key)
-                .build(),
+                .build_and_seal(&owner_key),
             vec![owner_proof.clone()],
         );
 
@@ -267,8 +256,7 @@ mod resource_access_rules {
                 .call_method(component_address, "take_tokens", args![Amount(10)])
                 .put_last_instruction_output_on_workspace("tokens")
                 .call_method(owner_account, "deposit", args![Workspace("tokens")])
-                .sign(&user_key)
-                .build(),
+                .build_and_seal(&user_key),
             vec![user_proof.clone()],
         );
 
@@ -280,8 +268,7 @@ mod resource_access_rules {
                 .call_method(component_address, "take_tokens", args![Amount(10)])
                 .put_last_instruction_output_on_workspace("tokens")
                 .call_method(owner_account, "deposit", args![Workspace("tokens")])
-                .sign(&owner_key)
-                .build(),
+                .build_and_seal(&owner_key),
             vec![owner_proof.clone()],
         );
 
@@ -291,8 +278,7 @@ mod resource_access_rules {
                 .call_method(component_address, "set_tokens_access_rules", args![
                     ResourceAccessRules::new().withdrawable(rule!(non_fungible(user_proof.clone())))
                 ])
-                .sign(&owner_key)
-                .build(),
+                .build_and_seal(&owner_key),
             vec![owner_proof],
         );
 
@@ -302,8 +288,7 @@ mod resource_access_rules {
                 .call_method(component_address, "take_tokens", args![Amount(10)])
                 .put_last_instruction_output_on_workspace("tokens")
                 .call_method(owner_account, "deposit", args![Workspace("tokens")])
-                .sign(&user_key)
-                .build(),
+                .build_and_seal(&user_key),
             vec![user_proof],
         );
     }
@@ -331,8 +316,7 @@ mod resource_access_rules {
                     // Badge recall rule
                     AccessRule::DenyAll
                 ])
-                .sign(&owner_key)
-                .build(),
+                .build_and_seal(&owner_key),
             vec![owner_proof.clone()],
         );
 
@@ -349,8 +333,7 @@ mod resource_access_rules {
                 .put_last_instruction_output_on_workspace("deposit_perm")
                 .call_method(user_account, "deposit", args![Workspace("withdraw_perm")])
                 .call_method(user_account, "deposit", args![Workspace("deposit_perm")])
-                .sign(&owner_key)
-                .build(),
+                .build_and_seal(&owner_key),
             vec![owner_proof.clone()],
         );
 
@@ -371,8 +354,7 @@ mod resource_access_rules {
                     user_badge_vault_id,
                     "withdraw"
                 ])
-                .sign(&owner_key)
-                .build(),
+                .build_and_seal(&owner_key),
             vec![owner_proof.clone()],
         );
 
@@ -393,8 +375,7 @@ mod resource_access_rules {
         let result = test.execute_expect_success(
             Transaction::builder()
                 .call_function(access_rules_template, "using_badge_rules", args![])
-                .sign(&owner_key)
-                .build(),
+                .build_and_seal(&owner_key),
             vec![owner_proof.clone()],
         );
 
@@ -421,8 +402,7 @@ mod resource_access_rules {
                 .call_method(component_address, "take_tokens", args![Amount(10)])
                 .put_last_instruction_output_on_workspace("tokens")
                 .call_method(user_account, "deposit", args![Workspace("tokens")])
-                .sign(&user_key)
-                .build(),
+                .build_and_seal(&user_key),
             vec![user_proof.clone()],
         );
 
@@ -437,8 +417,7 @@ mod resource_access_rules {
                 .put_last_instruction_output_on_workspace("deposit_perm")
                 .call_method(user_account, "deposit", args![Workspace("withdraw_perm")])
                 .call_method(user_account, "deposit", args![Workspace("deposit_perm")])
-                .sign(&owner_key)
-                .build(),
+                .build_and_seal(&owner_key),
             vec![owner_proof.clone()],
         );
 
@@ -461,8 +440,7 @@ mod resource_access_rules {
                 .put_last_instruction_output_on_workspace("tokens")
                 .call_method(user_account, "deposit", args![Workspace("tokens")])
                 .drop_all_proofs_in_workspace()
-                .sign(&user_key)
-                .build(),
+                .build_and_seal(&user_key),
             vec![user_proof.clone()],
         );
 
@@ -479,8 +457,7 @@ mod resource_access_rules {
                     user_badge_vault_id,
                     "withdraw"
                 ])
-                .sign(&owner_key)
-                .build(),
+                .build_and_seal(&owner_key),
             vec![owner_proof.clone()],
         );
 
@@ -493,8 +470,7 @@ mod resource_access_rules {
                 .put_last_instruction_output_on_workspace("tokens")
                 .call_method(user_account, "deposit", args![Workspace("tokens")])
                 .drop_all_proofs_in_workspace()
-                .sign(&user_key)
-                .build(),
+                .build_and_seal(&user_key),
             vec![user_proof],
         );
 
@@ -514,8 +490,7 @@ mod resource_access_rules {
         let result = test.execute_expect_success(
             Transaction::builder()
                 .call_function(access_rules_template, "using_resource_rules", args![])
-                .sign(&owner_key)
-                .build(),
+                .build_and_seal(&owner_key),
             vec![owner_proof.clone()],
         );
 
@@ -541,8 +516,7 @@ mod resource_access_rules {
                 .call_method(access_rules_component, "take_tokens", args![Amount(10)])
                 .put_last_instruction_output_on_workspace("tokens")
                 .call_method(user_account, "deposit", args![Workspace("tokens")])
-                .sign(&user_key)
-                .build(),
+                .build_and_seal(&user_key),
             vec![user_proof.clone()],
         );
 
@@ -554,8 +528,7 @@ mod resource_access_rules {
                 .call_method(access_rules_component, "mint_new_badge", args![])
                 .put_last_instruction_output_on_workspace("permission")
                 .call_method(user_account, "deposit", args![Workspace("permission")])
-                .sign(&owner_key)
-                .build(),
+                .build_and_seal(&owner_key),
             vec![owner_proof.clone()],
         );
 
@@ -571,8 +544,7 @@ mod resource_access_rules {
                 .put_last_instruction_output_on_workspace("tokens")
                 .call_method(user_account, "deposit", args![Workspace("tokens")])
                 .drop_all_proofs_in_workspace()
-                .sign(&user_key)
-                .build(),
+                .build_and_seal(&user_key),
             vec![user_proof.clone()],
         );
     }
@@ -598,8 +570,7 @@ mod resource_access_rules {
                     // Badge recall rule
                     AccessRule::DenyAll
                 ])
-                .sign(&owner_key)
-                .build(),
+                .build_and_seal(&owner_key),
             vec![owner_proof.clone()],
         );
 
@@ -633,8 +604,7 @@ mod resource_access_rules {
                 .call_method(owner_account, "withdraw", args![token_resource, Amount(1000)])
                 .put_last_instruction_output_on_workspace("tokens")
                 .call_method(owner_account, "deposit", args![Workspace("tokens")])
-                .sign(&owner_key)
-                .build(),
+                .build_and_seal(&owner_key),
             vec![owner_proof.clone()],
         );
 
@@ -655,8 +625,7 @@ mod resource_access_rules {
                 .call_method(owner_account, "withdraw", args![token_resource, Amount(1000)])
                 .put_last_instruction_output_on_workspace("tokens")
                 .call_method(owner_account, "deposit", args![Workspace("tokens")])
-                .sign(&owner_key)
-                .build(),
+                .build_and_seal(&owner_key),
             vec![owner_proof.clone()],
         );
     }
@@ -673,8 +642,7 @@ mod resource_access_rules {
         let result = test.execute_expect_success(
             Transaction::builder()
                 .call_function(access_rules_template, "using_resource_rules", args![])
-                .sign(&owner_key)
-                .build(),
+                .build_and_seal(&owner_key),
             vec![owner_proof.clone()],
         );
 
@@ -707,8 +675,7 @@ mod resource_access_rules {
                 .put_last_instruction_output_on_workspace("tokens")
                 .call_method(owner_account, "deposit", args![Workspace("tokens")])
                 .drop_all_proofs_in_workspace()
-                .sign(&owner_key)
-                .build(),
+                .build_and_seal(&owner_key),
             vec![owner_proof.clone()],
         );
 
@@ -741,8 +708,7 @@ mod resource_access_rules {
                 .put_last_instruction_output_on_workspace("tokens")
                 .call_method(owner_account, "deposit", args![Workspace("tokens")])
                 .drop_all_proofs_in_workspace()
-                .sign(&owner_key)
-                .build(),
+                .build_and_seal(&owner_key),
             vec![owner_proof.clone()],
         );
     }
@@ -761,8 +727,7 @@ mod resource_access_rules {
         let result = test.execute_expect_success(
             Transaction::builder()
                 .call_function(access_rules_template, "using_badge_rules", args![])
-                .sign(&owner_key)
-                .build(),
+                .build_and_seal(&owner_key),
             vec![owner_proof.clone()],
         );
 
@@ -788,8 +753,7 @@ mod resource_access_rules {
                 .call_method(component_address, "take_tokens", args![Amount(10)])
                 .put_last_instruction_output_on_workspace("tokens")
                 .call_method(user_account, "deposit", args![Workspace("tokens")])
-                .sign(&user_key)
-                .build(),
+                .build_and_seal(&user_key),
             vec![user_proof.clone()],
         );
 
@@ -804,8 +768,7 @@ mod resource_access_rules {
                 .put_last_instruction_output_on_workspace("deposit_perm")
                 .call_method(user_account, "deposit", args![Workspace("withdraw_perm")])
                 .call_method(user_account, "deposit", args![Workspace("deposit_perm")])
-                .sign(&owner_key)
-                .build(),
+                .build_and_seal(&owner_key),
             vec![owner_proof.clone()],
         );
 
@@ -841,8 +804,7 @@ mod resource_access_rules {
                 // Deposit before dropping the proof
                 .call_method(user_account, "deposit", args![Workspace("badges")])
                 .drop_all_proofs_in_workspace()
-                .sign(&owner_key)
-                .build(),
+                .build_and_seal(&owner_key),
             vec![user_proof.clone()],
         );
 
@@ -883,8 +845,7 @@ mod resource_access_rules {
                 .call_method(user_account, "deposit", args![Workspace("tokens")])
                 .drop_all_proofs_in_workspace()
                 .call_method(user_account, "deposit", args![Workspace("badges")])
-                .sign(&owner_key)
-                .build(),
+                .build_and_seal(&owner_key),
             vec![user_proof],
         );
     }
@@ -905,8 +866,7 @@ mod resource_access_rules {
                     "resource_actions_restricted_to_component",
                     args![],
                 )
-                .sign(&owner_key)
-                .build(),
+                .build_and_seal(&owner_key),
             vec![owner_proof.clone()],
         );
 
@@ -932,8 +892,7 @@ mod resource_access_rules {
                 .call_function(access_rules_template, "mint_resource", args![token_resource])
                 .put_last_instruction_output_on_workspace("tokens")
                 .call_method(owner_account, "deposit", args![Workspace("tokens")])
-                .sign(&owner_key)
-                .build(),
+                .build_and_seal(&owner_key),
             vec![owner_proof.clone()],
         );
 
@@ -945,8 +904,7 @@ mod resource_access_rules {
                 .call_method(component_address, "mint_more_tokens", args![Amount(1000)])
                 .put_last_instruction_output_on_workspace("tokens")
                 .call_method(owner_account, "deposit", args![Workspace("tokens")])
-                .sign(&owner_key)
-                .build(),
+                .build_and_seal(&owner_key),
             vec![owner_proof],
         );
     }
@@ -963,8 +921,7 @@ mod resource_access_rules {
         let result = test.execute_expect_success(
             Transaction::builder()
                 .call_function(access_rules_template, "with_auth_hook", args![true, "valid_auth_hook"])
-                .sign(&owner_key)
-                .build(),
+                .build_and_seal(&owner_key),
             vec![owner_proof.clone()],
         );
 
@@ -977,8 +934,7 @@ mod resource_access_rules {
                 .call_method(component_address, "take_tokens", args![Amount(10)])
                 .put_last_instruction_output_on_workspace("tokens")
                 .call_method(owner_account, "deposit", args![Workspace("tokens")])
-                .sign(&owner_key)
-                .build(),
+                .build_and_seal(&owner_key),
             vec![owner_proof.clone()],
         );
     }
@@ -994,8 +950,7 @@ mod resource_access_rules {
         let result = test.execute_expect_success(
             Transaction::builder()
                 .call_function(access_rules_template, "with_auth_hook", args![false, "valid_auth_hook"])
-                .sign(&owner_key)
-                .build(),
+                .build_and_seal(&owner_key),
             vec![owner_proof.clone()],
         );
 
@@ -1008,8 +963,7 @@ mod resource_access_rules {
                 .call_method(component_address, "take_tokens", args![Amount(10)])
                 .put_last_instruction_output_on_workspace("tokens")
                 .call_method(owner_account, "deposit", args![Workspace("tokens")])
-                .sign(&owner_key)
-                .build(),
+                .build_and_seal(&owner_key),
             vec![owner_proof.clone()],
         );
 
@@ -1034,8 +988,7 @@ mod resource_access_rules {
                     true,
                     "malicious_auth_hook_set_state"
                 ])
-                .sign(&owner_key)
-                .build(),
+                .build_and_seal(&owner_key),
             vec![owner_proof.clone()],
         );
 
@@ -1048,8 +1001,7 @@ mod resource_access_rules {
                 .call_method(component_address, "take_tokens", args![Amount(10)])
                 .put_last_instruction_output_on_workspace("tokens")
                 .call_method(user_account, "deposit", args![Workspace("tokens")])
-                .sign(&user_key)
-                .build(),
+                .build_and_seal(&user_key),
             vec![user_proof.clone()],
         );
 
@@ -1074,8 +1026,7 @@ mod resource_access_rules {
                     true,
                     "malicious_auth_hook_call_mut"
                 ])
-                .sign(&owner_key)
-                .build(),
+                .build_and_seal(&owner_key),
             vec![owner_proof.clone()],
         );
 
@@ -1088,8 +1039,7 @@ mod resource_access_rules {
                 .call_method(component_address, "take_tokens", args![Amount(10)])
                 .put_last_instruction_output_on_workspace("tokens")
                 .call_method(user_account, "deposit", args![Workspace("tokens")])
-                .sign(&user_key)
-                .build(),
+                .build_and_seal(&user_key),
             vec![user_proof.clone()],
         );
 
@@ -1113,8 +1063,7 @@ mod resource_access_rules {
         let result = test.execute_expect_success(
             Transaction::builder()
                 .call_function(state_template, "restricted", args![])
-                .sign(&user_key)
-                .build(),
+                .build_and_seal(&user_key),
             vec![owner_proof.clone()],
         );
 
@@ -1129,8 +1078,7 @@ mod resource_access_rules {
                 .call_function(access_rules_template, "with_auth_hook_attack_component", args![
                     state_component
                 ])
-                .sign(&owner_key)
-                .build(),
+                .build_and_seal(&owner_key),
             vec![owner_proof.clone()],
         );
 
@@ -1145,8 +1093,7 @@ mod resource_access_rules {
                 .call_method(state_component, "set", args![1])
                 // The hook should not be able to set the state component to 123
                 .call_method(user_account, "deposit", args![Workspace("tokens")])
-                .sign(&user_key)
-                .build(),
+                .build_and_seal(&user_key),
             vec![user_proof.clone()],
         );
 
@@ -1177,8 +1124,7 @@ mod resource_access_rules {
             let reason = test.execute_expect_failure(
                 Transaction::builder()
                     .call_function(access_rules_template, "with_auth_hook", args![true, hook])
-                    .sign(test.get_test_secret_key())
-                    .build(),
+                    .build_and_seal(test.get_test_secret_key()),
                 vec![test.get_test_proof()],
             );
 
diff --git a/dan_layer/engine/tests/account.rs b/dan_layer/engine/tests/account.rs
index 3febc167b..52a82ab9a 100644
--- a/dan_layer/engine/tests/account.rs
+++ b/dan_layer/engine/tests/account.rs
@@ -159,8 +159,7 @@ fn withdraw_from_account_prevented() {
             .call_method(source_account, "withdraw", args![faucet_resource, Amount(100)])
             .put_last_instruction_output_on_workspace("stolen_coins")
             .call_method(source_account, "deposit", args![Workspace("stolen_coins")])
-            .sign(&non_owning_key)
-            .build(),
+            .build_and_seal(&non_owning_key),
         // VNs provide the token that signed the transaction, which in this case is the non_owning_token
         vec![non_owning_token],
     );
@@ -204,8 +203,7 @@ fn attempt_to_overwrite_account() {
             // Create component with the same ID
             .create_account(source_account_pk)
             // Signed by source account so that it can pay the fees for the new account creation
-            .sign(&source_account_sk)
-            .build(),
+            .build_and_seal(&source_account_sk),
         vec![source_account_proof],
     );
 
@@ -217,8 +215,7 @@ fn attempt_to_overwrite_account() {
     let result = template_test.execute_expect_success(
         Transaction::builder()
             .call_method(source_account, "get_balances", args![])
-            .sign(&source_account_sk)
-            .build(),
+            .build_and_seal(&source_account_sk),
         vec![],
     );
 
@@ -240,6 +237,8 @@ fn gasless() {
     let (user_account, user_account_proof, user_account_sk) = test.create_funded_account();
     let (user2_account, _, _) = test.create_empty_account();
 
+    let fee_account_pk = RistrettoPublicKey::from_secret_key(&fee_account_sk);
+
     let result = test.execute_expect_success(
         Transaction::builder()
             .fee_transaction_pay_from_component(fee_account, Amount(1000))
@@ -247,9 +246,8 @@ fn gasless() {
             .put_last_instruction_output_on_workspace("b")
             .call_method(user2_account, "deposit", args![Workspace("b")])
             .call_method(user2_account, "get_balances", args![])
-            .build()
-            .sign(&fee_account_sk)
-            .sign(&user_account_sk),
+            .add_signature(&fee_account_pk, &user_account_sk)
+            .build_and_seal(&fee_account_sk),
         vec![fee_account_proof, user_account_proof],
     );
 
@@ -285,8 +283,7 @@ fn custom_access_rules() {
                 Some("bucket"),
             )
             // Signed by source account so that it can pay the fees for the new account creation
-            .sign(&secret_key)
-            .build(),
+            .build_and_seal(&secret_key),
         vec![owner_proof],
     );
     let user_account = result.finalize.execution_results[2].decode().unwrap();
@@ -298,8 +295,7 @@ fn custom_access_rules() {
             .call_method(user_account, "withdraw", args![XTR, Amount(100)])
             .put_last_instruction_output_on_workspace("b")
             .call_method(user2_account, "deposit", args![Workspace("b")])
-            .build()
-            .sign(&user2_secret_key),
+            .build_and_seal(&user2_secret_key),
         vec![user2_account_proof],
     );
 }
diff --git a/dan_layer/engine/tests/address_allocation.rs b/dan_layer/engine/tests/address_allocation.rs
index 8ac3d7246..264e60455 100644
--- a/dan_layer/engine/tests/address_allocation.rs
+++ b/dan_layer/engine/tests/address_allocation.rs
@@ -13,8 +13,7 @@ fn it_uses_allocation_address() {
     let result = test.execute_expect_success(
         Transaction::builder()
             .call_function(test.get_template_address("AddressAllocationTest"), "create", args![])
-            .sign(test.get_test_secret_key())
-            .build(),
+            .build_and_seal(test.get_test_secret_key()),
         vec![],
     );
 
@@ -43,8 +42,7 @@ fn it_fails_if_allocation_is_not_used() {
     let reason = test.execute_expect_failure(
         Transaction::builder()
             .call_function(template_addr, "drop_allocation", args![])
-            .sign(test.get_test_secret_key())
-            .build(),
+            .build_and_seal(test.get_test_secret_key()),
         vec![],
     );
 
diff --git a/dan_layer/engine/tests/asserts.rs b/dan_layer/engine/tests/asserts.rs
index cd4e87435..f4758c096 100644
--- a/dan_layer/engine/tests/asserts.rs
+++ b/dan_layer/engine/tests/asserts.rs
@@ -74,8 +74,7 @@ fn successful_assert() {
             .put_last_instruction_output_on_workspace("faucet_bucket")
             .assert_bucket_contains("faucet_bucket", test.faucet_resource, FAUCET_WITHDRAWAL_AMOUNT)
             .call_method(test.account, "deposit", args![Workspace("faucet_bucket")])
-            .sign(&test.account_key)
-            .build(),
+            .build_and_seal(&test.account_key),
         vec![test.account_proof.clone()],
     );
 }
@@ -93,8 +92,7 @@ fn it_fails_with_invalid_resource() {
             .put_last_instruction_output_on_workspace("faucet_bucket")
             .assert_bucket_contains("faucet_bucket", invalid_resource_address, FAUCET_WITHDRAWAL_AMOUNT)
             .call_method(test.account, "deposit", args![Workspace("faucet_bucket")])
-            .sign(&test.account_key)
-            .build(),
+            .build_and_seal(&test.account_key),
         vec![test.account_proof.clone()],
     );
 
@@ -120,8 +118,7 @@ fn it_fails_with_invalid_amount() {
             .put_last_instruction_output_on_workspace("faucet_bucket")
             .assert_bucket_contains("faucet_bucket", test.faucet_resource, min_amount)
             .call_method(test.account, "deposit", args![Workspace("faucet_bucket")])
-            .sign(&test.account_key)
-            .build(),
+            .build_and_seal(&test.account_key),
         vec![test.account_proof.clone()],
     );
 
@@ -146,8 +143,7 @@ fn it_fails_with_invalid_bucket() {
             .put_last_instruction_output_on_workspace("invalid_bucket")
             .assert_bucket_contains("invalid_bucket", test.faucet_resource, FAUCET_WITHDRAWAL_AMOUNT)
             .call_method(test.account, "deposit", args![Workspace("faucet_bucket")])
-            .sign(&test.account_key)
-            .build(),
+            .build_and_seal(&test.account_key),
         vec![test.account_proof.clone()],
     );
 
@@ -165,8 +161,7 @@ fn it_fails_with_invalid_workspace_key() {
             // we are going to assert a key that does not exist in the workspace
             .assert_bucket_contains("invalid_key", test.faucet_resource, FAUCET_WITHDRAWAL_AMOUNT)
             .call_method(test.account, "deposit", args![Workspace("faucet_bucket")])
-            .sign(&test.account_key)
-            .build(),
+            .build_and_seal(&test.account_key),
         vec![test.account_proof.clone()],
     );
 
diff --git a/dan_layer/engine/tests/composability.rs b/dan_layer/engine/tests/composability.rs
index 85e0eea98..2e063d03d 100644
--- a/dan_layer/engine/tests/composability.rs
+++ b/dan_layer/engine/tests/composability.rs
@@ -250,8 +250,7 @@ fn it_fails_on_invalid_calls() {
         .try_execute(
             Transaction::builder()
                 .call_method(components.composability_component, "invalid_state_call", args![])
-                .sign(&private_key)
-                .build(),
+                .build_and_seal(&private_key),
             vec![],
         )
         .unwrap();
@@ -286,8 +285,7 @@ fn it_does_not_propagate_permissions() {
                     fungible_resource,
                     Amount(100)
                 ])
-                .sign(&attacker_key)
-                .build(),
+                .build_and_seal(&attacker_key),
             // note that we are actually passing a valid proof of ownership for the victim. In reality, the engine only
             // passes the transaction signer proof but we are assuming the attacker was able to somehow
             // inject into the auth scope so that we can assert that proofs are not propagated in cross-template calls.
@@ -357,8 +355,7 @@ fn it_fails_when_surpassing_recursion_limit() {
         .try_execute(
             Transaction::builder()
                 .call_method(last_composability_component, "get_nested_value", args![])
-                .sign(&private_key)
-                .build(),
+                .build_and_seal(&private_key),
             vec![],
         )
         .unwrap();
diff --git a/dan_layer/engine/tests/confidential.rs b/dan_layer/engine/tests/confidential.rs
index aaef35449..228e3f74c 100644
--- a/dan_layer/engine/tests/confidential.rs
+++ b/dan_layer/engine/tests/confidential.rs
@@ -84,8 +84,7 @@ fn mint_more_later() {
             .call_method(faucet, "take_free_coins", args![withdraw_proof.proof])
             .put_last_instruction_output_on_workspace("coins")
             .call_method(user_account, "deposit", args![Workspace("coins")])
-            .sign(&user_key)
-            .build(),
+            .build_and_seal(&user_key),
         vec![user_proof],
     );
 }
@@ -434,8 +433,7 @@ fn mint_and_transfer_revealed() {
             .put_last_instruction_output_on_workspace("b")
             .call_method(user_account, "deposit", args![Workspace("b")])
             .call_method(user_account, "balance", args![faucet_resx])
-            .sign(test.get_test_secret_key())
-            .build(),
+            .build_and_seal(test.get_test_secret_key()),
         vec![],
     );
 
@@ -452,8 +450,7 @@ fn mint_revealed_with_invalid_proof() {
     let reason = test.execute_expect_failure(
         Transaction::builder()
             .call_method(faucet, "mint_revealed_with_range_proof", args![Amount(123)])
-            .sign(test.get_test_secret_key())
-            .build(),
+            .build_and_seal(test.get_test_secret_key()),
         vec![],
     );
 
@@ -488,8 +485,7 @@ fn mint_with_view_key() {
             .call_method(faucet, "take_free_coins", args![withdraw_proof.proof])
             .put_last_instruction_output_on_workspace("coins")
             .call_method(user_account, "deposit", args![Workspace("coins")])
-            .sign(&user_key)
-            .build(),
+            .build_and_seal(&user_key),
         vec![user_proof],
     );
 
diff --git a/dan_layer/engine/tests/events.rs b/dan_layer/engine/tests/events.rs
index 701606d80..1d8978b29 100644
--- a/dan_layer/engine/tests/events.rs
+++ b/dan_layer/engine/tests/events.rs
@@ -46,8 +46,7 @@ fn cannot_use_standard_topic() {
     let reason = template_test.execute_expect_failure(
         Transaction::builder()
             .call_function(event_emitter_template, "test_function", args![invalid_topic])
-            .sign(&private_key)
-            .build(),
+            .build_and_seal(&private_key),
         [].into(),
     );
     assert_reject_reason(reason, RuntimeError::InvalidEventTopic {
diff --git a/dan_layer/engine/tests/fees.rs b/dan_layer/engine/tests/fees.rs
index f961fb476..cf9487e14 100644
--- a/dan_layer/engine/tests/fees.rs
+++ b/dan_layer/engine/tests/fees.rs
@@ -25,8 +25,7 @@ fn deducts_fees_from_payments_and_refunds_the_rest() {
         Transaction::builder()
             .fee_transaction_pay_from_component(account, Amount(1000))
             .call_function(test.get_template_address("State"), "new", args![])
-            .sign(&private_key)
-            .build(),
+            .build_and_seal(&private_key),
         vec![owner_token],
     );
 
@@ -53,8 +52,7 @@ fn deducts_fees_when_transaction_fails() {
         Transaction::builder()
             .fee_transaction_pay_from_component(account, Amount(1000))
             .call_function(test.get_template_address("State"), "this_doesnt_exist", args![])
-            .sign(&private_key)
-            .build(),
+            .build_and_seal(&private_key),
         vec![owner_token],
     );
 
@@ -100,8 +98,7 @@ fn deposit_from_faucet_then_pay() {
                 },
             ])
             .call_function(test.get_template_address("State"), "new", args![])
-            .sign(&private_key)
-            .build(),
+            .build_and_seal(&private_key),
         vec![owner_token],
     );
 
@@ -139,8 +136,7 @@ fn another_account_pays_partially_for_fees() {
                 .call_method(test_faucet_component(), "take_free_coins", args![])
                 .put_last_instruction_output_on_workspace("bucket")
                 .call_method(account, "deposit", args![Workspace("bucket")])
-                .sign(&private_key)
-                .build(),
+                .build_and_seal(&private_key),
         vec![owner_token_fee, owner_token],
     );
 
@@ -181,8 +177,7 @@ fn failed_fee_transaction() {
                     args: args![],
                 }])
                 .call_function(test.get_template_address("State"), "new", args![])
-                .sign(&private_key)
-                .build(),
+                .build_and_seal(&private_key),
             vec![owner_token],
         )
         .unwrap();
@@ -218,8 +213,7 @@ fn fail_partial_paid_fees() {
                 ])
                 .put_last_instruction_output_on_workspace("bucket")
                 .call_method(account, "deposit", args![Workspace("bucket")])
-                .sign(&private_key)
-                .build(),
+                .build_and_seal(&private_key),
         vec![owner_token, owner_token2],
     );
 
@@ -266,7 +260,6 @@ fn fail_pay_less_fees_than_fee_transaction() {
                             args: args![Amount(100)],
                         }
                     ))
-                    .collect()
                 )
                 // These instructions should not be applied
                 .call_method(account2, "withdraw", args![
@@ -275,8 +268,7 @@ fn fail_pay_less_fees_than_fee_transaction() {
                 ])
                 .put_last_instruction_output_on_workspace("bucket")
                 .call_method(account, "deposit", args![Workspace("bucket")])
-                .sign(&private_key)
-                .build(),
+                .build_and_seal(&private_key),
             vec![owner_token, owner_token2],
         )
         .unwrap();
@@ -318,8 +310,7 @@ fn fail_pay_too_little_no_fee_instruction() {
                 .put_last_instruction_output_on_workspace("bucket")
                 .call_method(account, "deposit", args![Workspace("bucket")])
                 .call_method(account,"pay_fee",  args![Amount(10)])
-                .sign(&private_key)
-                .build(),
+                .build_and_seal(&private_key),
         vec![owner_token, owner_token2],
     );
 
@@ -351,8 +342,7 @@ fn success_pay_fee_in_main_instructions() {
             .put_last_instruction_output_on_workspace("bucket")
             .call_method(account, "deposit", args![Workspace("bucket")])
             .call_method(account, "pay_fee", args![Amount(1000)])
-            .sign(&private_key)
-            .build(),
+            .build_and_seal(&private_key),
         vec![owner_token, owner_token2],
     );
 
@@ -382,8 +372,7 @@ fn dangling_bucket_pay_fees() {
                 Amount(10)
             ])
             .put_last_instruction_output_on_workspace("dangling_bucket")
-            .sign(&private_key)
-            .build(),
+            .build_and_seal(&private_key),
         vec![owner_token],
     );
 
diff --git a/dan_layer/engine/tests/publish_template.rs b/dan_layer/engine/tests/publish_template.rs
index 1a5d46b2e..5bf040746 100644
--- a/dan_layer/engine/tests/publish_template.rs
+++ b/dan_layer/engine/tests/publish_template.rs
@@ -32,8 +32,7 @@ fn publish_template_success() {
         Transaction::builder()
             .fee_transaction_pay_from_component(account_address, Amount(200_000))
             .publish_template(template.code().to_vec())
-            .sign(&account_key)
-            .build(),
+            .build_and_seal(&account_key),
         vec![owner_proof],
     );
 
@@ -65,8 +64,7 @@ fn publish_template_invalid_binary() {
         Transaction::builder()
             .fee_transaction_pay_from_component(account_address, Amount(200_000))
             .publish_template(vec![1, 2, 3])
-            .sign(&account_key)
-            .build(),
+            .build_and_seal(&account_key),
         vec![owner_proof],
     );
 
@@ -87,8 +85,7 @@ fn publish_template_too_big_binary() {
         Transaction::builder()
             .fee_transaction_pay_from_component(account_address, Amount(200_000))
             .publish_template(random_wasm_binary)
-            .sign(&account_key)
-            .build(),
+            .build_and_seal(&account_key),
         vec![owner_proof],
     );
 
diff --git a/dan_layer/engine/tests/recall.rs b/dan_layer/engine/tests/recall.rs
index f229fcb28..454b687e1 100644
--- a/dan_layer/engine/tests/recall.rs
+++ b/dan_layer/engine/tests/recall.rs
@@ -25,8 +25,7 @@ fn it_recalls_all_resource_types() {
     let result = test.execute_expect_success(
         Transaction::builder()
             .call_function(recall_template, "new", args![initial_supply])
-            .sign(test.get_test_secret_key())
-            .build(),
+            .build_and_seal(test.get_test_secret_key()),
         vec![],
     );
 
@@ -45,8 +44,7 @@ fn it_recalls_all_resource_types() {
             .call_method(account, "deposit", args![Workspace("buckets.0")])
             .call_method(account, "deposit", args![Workspace("buckets.1")])
             .call_method(account, "deposit", args![Workspace("buckets.2")])
-            .sign(test.get_test_secret_key())
-            .build(),
+            .build_and_seal(test.get_test_secret_key()),
         vec![],
     );
 
@@ -72,8 +70,7 @@ fn it_recalls_all_resource_types() {
             .call_method(account, "balance", args![fungible_resource])
             .call_method(account, "balance", args![non_fungible_resource])
             .call_method(account, "balance", args![confidential_resource])
-            .sign(test.get_test_secret_key())
-            .build(),
+            .build_and_seal(test.get_test_secret_key()),
         vec![],
     );
 
diff --git a/dan_layer/engine/tests/reentrancy.rs b/dan_layer/engine/tests/reentrancy.rs
index edd06286b..f795fb8cd 100644
--- a/dan_layer/engine/tests/reentrancy.rs
+++ b/dan_layer/engine/tests/reentrancy.rs
@@ -20,8 +20,7 @@ fn it_prevents_reentrant_withdraw() {
     let result = test.execute_expect_success(
         Transaction::builder()
             .call_function(faucet_addr, "mint", args![Amount(1000)])
-            .sign(test.get_test_secret_key())
-            .build(),
+            .build_and_seal(test.get_test_secret_key()),
         vec![],
     );
 
@@ -34,8 +33,7 @@ fn it_prevents_reentrant_withdraw() {
             .call_method(faucet, "take_free_coins", args![])
             .put_last_instruction_output_on_workspace("bucket")
             .call_function(template_addr, "with_bucket", args![Workspace("bucket")])
-            .sign(test.get_test_secret_key())
-            .build(),
+            .build_and_seal(test.get_test_secret_key()),
         vec![],
     );
 
@@ -50,8 +48,7 @@ fn it_prevents_reentrant_withdraw() {
             .put_last_instruction_output_on_workspace("bucket")
             .call_method(reentrancy, "get_balance", args![])
             .call_method(account, "deposit", args![Workspace("bucket")])
-            .sign(test.get_test_secret_key())
-            .build(),
+            .build_and_seal(test.get_test_secret_key()),
         vec![],
     );
     // Locked for read but attempted to lock the same component for write
@@ -69,8 +66,7 @@ fn it_allows_multiple_immutable_access_to_component() {
     test.execute_expect_success(
         Transaction::builder()
             .call_method(reentrancy, "reentrant_access_immutable", args![])
-            .sign(test.get_test_secret_key())
-            .build(),
+            .build_and_seal(test.get_test_secret_key()),
         vec![],
     );
 }
@@ -84,8 +80,7 @@ fn it_prevents_read_access_to_mutating_component() {
     let reason = test.execute_expect_failure(
         Transaction::builder()
             .call_method(reentrancy, "reentrant_access", args![])
-            .sign(test.get_test_secret_key())
-            .build(),
+            .build_and_seal(test.get_test_secret_key()),
         vec![],
     );
 
@@ -106,8 +101,7 @@ fn it_prevents_multiple_mutable_access_to_component() {
     let reason = test.execute_expect_failure(
         Transaction::builder()
             .call_method(reentrancy, "reentrant_access_mut", args![])
-            .sign(test.get_test_secret_key())
-            .build(),
+            .build_and_seal(test.get_test_secret_key()),
         vec![],
     );
 
diff --git a/dan_layer/engine/tests/shenanigans.rs b/dan_layer/engine/tests/shenanigans.rs
index 40daa0212..e0525a7fa 100644
--- a/dan_layer/engine/tests/shenanigans.rs
+++ b/dan_layer/engine/tests/shenanigans.rs
@@ -21,8 +21,7 @@ fn it_rejects_dangling_vaults_in_constructor() {
     let reason = test.execute_expect_failure(
         Transaction::builder()
             .call_function(template_addr, "dangling_vault", args![])
-            .sign(test.get_test_secret_key())
-            .build(),
+            .build_and_seal(test.get_test_secret_key()),
         vec![],
     );
 
@@ -41,8 +40,7 @@ fn it_rejects_dangling_vault_that_has_been_returned() {
     let reason = test.execute_expect_failure(
         Transaction::builder()
             .call_function(template_addr, "return_vault", args![])
-            .sign(test.get_test_secret_key())
-            .build(),
+            .build_and_seal(test.get_test_secret_key()),
         vec![],
     );
 
@@ -58,8 +56,7 @@ fn it_rejects_dangling_vaults_in_component() {
     let result = test.execute_expect_success(
         Transaction::builder()
             .call_function(template_addr, "with_vault", args![])
-            .sign(test.get_test_secret_key())
-            .build(),
+            .build_and_seal(test.get_test_secret_key()),
         vec![],
     );
 
@@ -72,8 +69,7 @@ fn it_rejects_dangling_vaults_in_component() {
     let reason = test.execute_expect_failure(
         Transaction::builder()
             .call_method(component_address, "drop_vault", args![])
-            .sign(test.get_test_secret_key())
-            .build(),
+            .build_and_seal(test.get_test_secret_key()),
         vec![test.get_test_proof()],
     );
 
@@ -90,8 +86,7 @@ fn it_rejects_dangling_resources() {
     let reason = test.execute_expect_failure(
         Transaction::builder()
             .call_function(template_addr, "dangling_resource", args![])
-            .sign(test.get_test_secret_key())
-            .build(),
+            .build_and_seal(test.get_test_secret_key()),
         vec![],
     );
 
@@ -106,8 +101,7 @@ fn it_rejects_unknown_substate_addresses() {
     let reason = test.execute_expect_failure(
         Transaction::builder()
             .call_function(template_addr, "non_existent_id", args![])
-            .sign(test.get_test_secret_key())
-            .build(),
+            .build_and_seal(test.get_test_secret_key()),
         vec![],
     );
 
@@ -127,8 +121,7 @@ fn it_rejects_references_to_buckets_that_arent_in_scope() {
     let result = test.execute_expect_success(
         Transaction::builder()
             .call_function(template_addr, "with_vault", args![])
-            .sign(&owner_key)
-            .build(),
+            .build_and_seal(&owner_key),
         vec![owner_token.clone()],
     );
 
@@ -141,8 +134,7 @@ fn it_rejects_references_to_buckets_that_arent_in_scope() {
             .call_method(account, "withdraw", args![XTR, Amount(1000)])
             .put_last_instruction_output_on_workspace("bucket")
             .call_method(shenanigans, "take_bucket_zero", args![])
-            .sign(&owner_key)
-            .build(),
+            .build_and_seal(&owner_key),
         vec![owner_token],
     );
 
@@ -158,8 +150,7 @@ fn it_rejects_double_ownership_of_vault() {
     let reason = test.execute_expect_failure(
         Transaction::builder()
             .call_function(template_addr, "with_vault_copy", args![])
-            .sign(test.get_test_secret_key())
-            .build(),
+            .build_and_seal(test.get_test_secret_key()),
         vec![test.get_test_proof()],
     );
 
@@ -181,8 +172,7 @@ fn it_prevents_access_to_vault_id_in_component_context() {
     let result = test.execute_expect_success(
         Transaction::builder()
             .call_function(template_addr, "with_vault", args![])
-            .sign(test.get_test_secret_key())
-            .build(),
+            .build_and_seal(test.get_test_secret_key()),
         vec![test.get_test_proof()],
     );
 
@@ -193,8 +183,7 @@ fn it_prevents_access_to_vault_id_in_component_context() {
     let reason = test.execute_expect_failure(
         Transaction::builder()
             .call_method(shenanigans, "take_from_a_vault", args![vault_id, Amount(1000)])
-            .sign(test.get_test_secret_key())
-            .build(),
+            .build_and_seal(test.get_test_secret_key()),
         vec![test.get_test_proof()],
     );
 
@@ -214,8 +203,7 @@ fn it_prevents_access_to_out_of_scope_component() {
     let result = test.execute_expect_success(
         Transaction::builder()
             .call_function(template_addr, "new", args![])
-            .sign(test.get_test_secret_key())
-            .build(),
+            .build_and_seal(test.get_test_secret_key()),
         vec![test.get_test_proof()],
     );
 
@@ -226,8 +214,7 @@ fn it_prevents_access_to_out_of_scope_component() {
     let reason = test.execute_expect_failure(
         Transaction::builder()
             .call_method(shenanigans, "empty_state_on_component", args![account])
-            .sign(test.get_test_secret_key())
-            .build(),
+            .build_and_seal(test.get_test_secret_key()),
         vec![test.get_test_proof()],
     );
 
@@ -258,8 +245,7 @@ fn it_disallows_calls_on_vaults_that_are_not_owned_by_current_component() {
                 "attempt_to_steal_funds_using_cross_template_call",
                 args![vault_id, attacker, Some(Amount(1000))],
             )
-            .sign(test.get_test_secret_key())
-            .build(),
+            .build_and_seal(test.get_test_secret_key()),
         vec![test.get_test_proof()],
     );
 
@@ -285,8 +271,7 @@ fn it_disallows_vault_access_if_vault_is_not_owned() {
     let reason = test.execute_expect_failure(
         Transaction::builder()
             .call_function(template_addr, "ref_stolen_vault", args![vault_id])
-            .sign(test.get_test_secret_key())
-            .build(),
+            .build_and_seal(test.get_test_secret_key()),
         vec![test.get_test_proof()],
     );
 
@@ -306,8 +291,7 @@ fn it_disallows_minting_different_resource_type() {
     let result = test.execute_expect_success(
         Transaction::builder()
             .call_function(template_addr, "new", args![])
-            .sign(test.get_test_secret_key())
-            .build(),
+            .build_and_seal(test.get_test_secret_key()),
         vec![],
     );
 
@@ -320,8 +304,7 @@ fn it_disallows_minting_different_resource_type() {
             .call_method(component, "mint_different_resource_type", args![])
             .put_last_instruction_output_on_workspace("bucket")
             .call_method(account, "deposit", args![Workspace("bucket")])
-            .sign(test.get_test_secret_key())
-            .build(),
+            .build_and_seal(test.get_test_secret_key()),
         vec![],
     );
 
diff --git a/dan_layer/engine/tests/test.rs b/dan_layer/engine/tests/test.rs
index 3a24c0515..e0bf95efd 100644
--- a/dan_layer/engine/tests/test.rs
+++ b/dan_layer/engine/tests/test.rs
@@ -223,8 +223,7 @@ fn test_engine_errors() {
         .try_execute(
             Transaction::builder()
                 .call_function(test.get_template_address("Errors"), "invalid_engine_call", args![])
-                .sign(&Default::default())
-                .build(),
+                .build_and_seal(&Default::default()),
             vec![],
         )
         .unwrap();
@@ -327,8 +326,7 @@ fn test_errors_on_infinite_loop() {
     let reason = test.execute_expect_failure(
         Transaction::builder()
             .call_function(test.get_template_address("InfinityLoopTest"), "infinity_loop", args![])
-            .sign(test.get_test_secret_key())
-            .build(),
+            .build_and_seal(test.get_test_secret_key()),
         vec![],
     );
     // Transaction failed: Execution failure: RuntimeError: unreachable\n    at tari_free (<module>[327]:0x2390c)
@@ -1126,8 +1124,7 @@ mod tickets {
         let result = template_test.execute_expect_success(
             Transaction::builder()
                 .call_function(faucet_template, "mint", args![initial_supply])
-                .sign(&secret)
-                .build(),
+                .build_and_seal(&secret),
             vec![],
         );
         let faucet_component: ComponentAddress = result.finalize.execution_results[0].decode().unwrap();
@@ -1152,8 +1149,7 @@ mod tickets {
                     price,
                     event_description
                 ])
-                .sign(&secret)
-                .build(),
+                .build_and_seal(&secret),
             vec![owner_proof.clone()],
         );
         let ticket_seller: ComponentAddress = result.finalize.execution_results[0].decode().unwrap();
@@ -1175,8 +1171,7 @@ mod tickets {
                 .call_method(faucet_component, "take_free_coins", args![])
                 .put_last_instruction_output_on_workspace("coins")
                 .call_method(account_address, "deposit", args![Workspace("coins")])
-                .sign(&secret)
-                .build(),
+                .build_and_seal(&secret),
             vec![],
         );
 
@@ -1188,8 +1183,7 @@ mod tickets {
                 .call_method(ticket_seller, "buy_ticket", args![Workspace("payment")])
                 .put_last_instruction_output_on_workspace("nft_bucket")
                 .call_method(account_address, "deposit", args![Workspace("nft_bucket")])
-                .sign(&secret)
-                .build(),
+                .build_and_seal(&secret),
             vec![owner_proof],
         );
 
diff --git a/dan_layer/engine_types/Cargo.toml b/dan_layer/engine_types/Cargo.toml
index 040f2edd5..9d2e96639 100644
--- a/dan_layer/engine_types/Cargo.toml
+++ b/dan_layer/engine_types/Cargo.toml
@@ -30,6 +30,8 @@ serde_json = { workspace = true }
 thiserror = { workspace = true }
 ts-rs = { workspace = true, optional = true }
 
+log = { workspace = true }
+
 [features]
 default = []
 ts = ["ts-rs", "tari_template_lib/ts", "tari_template_abi/ts"]
diff --git a/dan_layer/engine_types/src/commit_result.rs b/dan_layer/engine_types/src/commit_result.rs
index 1562618c0..a98aa86ec 100644
--- a/dan_layer/engine_types/src/commit_result.rs
+++ b/dan_layer/engine_types/src/commit_result.rs
@@ -234,6 +234,14 @@ impl TransactionResult {
         }
     }
 
+    pub fn into_accept(self) -> Option<SubstateDiff> {
+        match self {
+            Self::Accept(substate_diff) => Some(substate_diff),
+            Self::AcceptFeeRejectRest(substate_diff, _) => Some(substate_diff),
+            Self::Reject(_) => None,
+        }
+    }
+
     pub fn reject(&self) -> Option<&RejectReason> {
         match self {
             Self::Accept(_) => None,
diff --git a/dan_layer/engine_types/src/indexed_value.rs b/dan_layer/engine_types/src/indexed_value.rs
index bf8902ea5..67c87894a 100644
--- a/dan_layer/engine_types/src/indexed_value.rs
+++ b/dan_layer/engine_types/src/indexed_value.rs
@@ -114,17 +114,21 @@ impl IndexedValue {
     where for<'a> T: serde::Deserialize<'a> {
         decode_value_at_path(&self.value, path)
     }
-}
 
-impl Default for IndexedValue {
-    fn default() -> Self {
+    pub const fn empty() -> Self {
         Self {
-            indexed: IndexedWellKnownTypes::default(),
+            indexed: IndexedWellKnownTypes::new(),
             value: tari_bor::Value::Null,
         }
     }
 }
 
+impl Default for IndexedValue {
+    fn default() -> Self {
+        Self::empty()
+    }
+}
+
 #[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq)]
 #[cfg_attr(feature = "ts", derive(TS), ts(export, export_to = "../../bindings/src/types/"))]
 pub struct IndexedWellKnownTypes {
diff --git a/dan_layer/engine_types/src/instruction_result.rs b/dan_layer/engine_types/src/instruction_result.rs
index aaae359f4..3aa95400a 100644
--- a/dan_layer/engine_types/src/instruction_result.rs
+++ b/dan_layer/engine_types/src/instruction_result.rs
@@ -36,9 +36,9 @@ pub struct InstructionResult {
 }
 
 impl InstructionResult {
-    pub fn empty() -> Self {
-        InstructionResult {
-            indexed: IndexedValue::default(),
+    pub const fn empty() -> Self {
+        Self {
+            indexed: IndexedValue::empty(),
             return_type: Type::Unit,
         }
     }
diff --git a/dan_layer/engine_types/src/published_template.rs b/dan_layer/engine_types/src/published_template.rs
index 0a9f71de3..f1b867bf8 100644
--- a/dan_layer/engine_types/src/published_template.rs
+++ b/dan_layer/engine_types/src/published_template.rs
@@ -8,11 +8,14 @@ use std::{
 };
 
 use tari_bor::{BorTag, Deserialize, Serialize};
+use tari_common_types::types::PublicKey;
 use tari_template_lib::{
     models::{BinaryTag, KeyParseError, ObjectKey},
     Hash,
 };
 
+use crate::hashing::{hasher32, template_hasher32, EngineHashDomainLabel};
+
 const TAG: u64 = BinaryTag::TemplateAddress.as_u64();
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
@@ -29,6 +32,15 @@ impl PublishedTemplateAddress {
         Self(BorTag::new(key))
     }
 
+    pub fn from_author_and_code(author_public_key: &PublicKey, code: &[u8]) -> Self {
+        let binary_hash = template_hasher32().chain(&code).result();
+        let hash = hasher32(EngineHashDomainLabel::TemplateAddress)
+            .chain(author_public_key)
+            .chain(&binary_hash)
+            .result();
+        Self::from_hash(hash)
+    }
+
     pub fn as_object_key(&self) -> &ObjectKey {
         self.0.inner()
     }
diff --git a/dan_layer/engine_types/src/substate.rs b/dan_layer/engine_types/src/substate.rs
index 038c0ed5f..30e96bc72 100644
--- a/dan_layer/engine_types/src/substate.rs
+++ b/dan_layer/engine_types/src/substate.rs
@@ -280,6 +280,10 @@ impl SubstateId {
         matches!(self, Self::TransactionReceipt(_))
     }
 
+    pub fn is_published_template(&self) -> bool {
+        matches!(self, Self::Template(_))
+    }
+
     pub fn is_read_only(&self) -> bool {
         matches!(self, Self::TransactionReceipt(_) | Self::Resource(_))
     }
@@ -558,6 +562,13 @@ impl SubstateValue {
         }
     }
 
+    pub fn into_template(self) -> Option<PublishedTemplate> {
+        match self {
+            SubstateValue::Template(template) => Some(template),
+            _ => None,
+        }
+    }
+
     pub fn as_component(&self) -> Option<&ComponentHeader> {
         match self {
             SubstateValue::Component(component) => Some(component),
diff --git a/dan_layer/p2p/proto/transaction.proto b/dan_layer/p2p/proto/transaction.proto
index a72cd2b77..e0c8fee87 100644
--- a/dan_layer/p2p/proto/transaction.proto
+++ b/dan_layer/p2p/proto/transaction.proto
@@ -17,18 +17,8 @@ message CommitmentSignature {
   bytes signature_v = 3;
 }
 
-message UnsignedTransaction {
-  repeated Instruction fee_instructions = 1;
-  repeated Instruction instructions = 2;
-  repeated SubstateRequirement inputs = 3;
-  tari.dan.common.Epoch min_epoch = 4;
-  tari.dan.common.Epoch max_epoch = 5;
-}
-
 message Transaction {
-  UnsignedTransaction transaction = 1;
-  repeated tari.dan.common.SignatureAndPublicKey signatures = 2;
-  repeated VersionedSubstateId filled_inputs = 3;
+  bytes bor_encoded = 1;
 }
 
 message Instruction {
diff --git a/dan_layer/p2p/src/conversions/transaction.rs b/dan_layer/p2p/src/conversions/transaction.rs
index a4f2c033c..f49c9a750 100644
--- a/dan_layer/p2p/src/conversions/transaction.rs
+++ b/dan_layer/p2p/src/conversions/transaction.rs
@@ -26,7 +26,7 @@ use anyhow::anyhow;
 use tari_bor::{decode_exact, encode};
 use tari_common_types::types::{Commitment, PrivateKey, PublicKey};
 use tari_crypto::{ristretto::RistrettoComSig, tari_utilities::ByteArray};
-use tari_dan_common_types::{Epoch, SubstateRequirement, VersionedSubstateId};
+use tari_dan_common_types::{SubstateRequirement, VersionedSubstateId};
 use tari_engine_types::{confidential::ConfidentialClaim, instruction::Instruction, substate::SubstateId};
 use tari_template_lib::{
     args::Arg,
@@ -43,7 +43,7 @@ use tari_template_lib::{
     },
     prelude::AccessRules,
 };
-use tari_transaction::{Transaction, UnsignedTransaction};
+use tari_transaction::Transaction;
 
 use crate::{
     proto::{
@@ -81,103 +81,76 @@ impl TryFrom<proto::transaction::NewTransactionMessage> for NewTransactionMessag
 impl TryFrom<proto::transaction::Transaction> for Transaction {
     type Error = anyhow::Error;
 
-    fn try_from(request: proto::transaction::Transaction) -> Result<Self, Self::Error> {
-        let signatures = request
-            .signatures
-            .into_iter()
-            .map(TryInto::try_into)
-            .collect::<Result<_, _>>()?;
-
-        let filled_inputs = request
-            .filled_inputs
-            .into_iter()
-            .map(TryInto::try_into)
-            .collect::<Result<_, _>>()?;
-
-        let transaction = Transaction::new(
-            request
-                .transaction
-                .map(TryInto::try_into)
-                .transpose()?
-                .ok_or_else(|| anyhow!("Unsigned transaction not provided"))?,
-            signatures,
-        )
-        .with_filled_inputs(filled_inputs);
-
-        Ok(transaction)
+    fn try_from(transaction: proto::transaction::Transaction) -> Result<Self, Self::Error> {
+        decode_exact(&transaction.bor_encoded).map_err(|e| anyhow!("tari_bor::decode failed for transaction: {}", e))
     }
 }
 
 impl From<&Transaction> for proto::transaction::Transaction {
     fn from(transaction: &Transaction) -> Self {
-        let signatures = transaction.signatures().iter().map(Into::into).collect();
-        let filled_inputs = transaction.filled_inputs().iter().map(Into::into).collect();
-
         proto::transaction::Transaction {
-            transaction: Some(transaction.unsigned_transaction().into()),
-            signatures,
-            filled_inputs,
+            bor_encoded: encode(transaction).expect("tari_bor::encode failed for transaction"),
         }
     }
 }
 
 //---------------------------------- UnsignedTransaction --------------------------------------------//
 
-impl TryFrom<proto::transaction::UnsignedTransaction> for UnsignedTransaction {
-    type Error = anyhow::Error;
-
-    fn try_from(request: proto::transaction::UnsignedTransaction) -> Result<Self, Self::Error> {
-        let instructions = request
-            .instructions
-            .into_iter()
-            .map(TryInto::try_into)
-            .collect::<Result<Vec<_>, _>>()?;
-
-        let fee_instructions = request
-            .fee_instructions
-            .into_iter()
-            .map(TryInto::try_into)
-            .collect::<Result<Vec<_>, _>>()?;
-
-        let inputs = request
-            .inputs
-            .into_iter()
-            .map(TryInto::try_into)
-            .collect::<Result<_, _>>()?;
-
-        let min_epoch = request.min_epoch.map(|epoch| Epoch(epoch.epoch));
-        let max_epoch = request.max_epoch.map(|epoch| Epoch(epoch.epoch));
-        Ok(Self {
-            fee_instructions,
-            instructions,
-            inputs,
-            min_epoch,
-            max_epoch,
-        })
-    }
-}
-
-impl From<&UnsignedTransaction> for proto::transaction::UnsignedTransaction {
-    fn from(transaction: &UnsignedTransaction) -> Self {
-        let inputs = transaction.inputs().iter().map(Into::into).collect();
-        let min_epoch = transaction
-            .min_epoch()
-            .map(|epoch| proto::common::Epoch { epoch: epoch.0 });
-        let max_epoch = transaction
-            .max_epoch()
-            .map(|epoch| proto::common::Epoch { epoch: epoch.0 });
-        let fee_instructions = transaction.fee_instructions().iter().cloned().map(Into::into).collect();
-        let instructions = transaction.instructions().iter().cloned().map(Into::into).collect();
-
-        proto::transaction::UnsignedTransaction {
-            fee_instructions,
-            instructions,
-            inputs,
-            min_epoch,
-            max_epoch,
-        }
-    }
-}
+// impl TryFrom<proto::transaction::UnsignedTransactionV1> for UnsignedTransactionV1 {
+//     type Error = anyhow::Error;
+//
+//     fn try_from(request: proto::transaction::UnsignedTransactionV1) -> Result<Self, Self::Error> {
+//         let instructions = request
+//             .instructions
+//             .into_iter()
+//             .map(TryInto::try_into)
+//             .collect::<Result<Vec<_>, _>>()?;
+//
+//         let fee_instructions = request
+//             .fee_instructions
+//             .into_iter()
+//             .map(TryInto::try_into)
+//             .collect::<Result<Vec<_>, _>>()?;
+//
+//         let inputs = request
+//             .inputs
+//             .into_iter()
+//             .map(TryInto::try_into)
+//             .collect::<Result<_, _>>()?;
+//
+//         let min_epoch = request.min_epoch.map(|epoch| Epoch(epoch.epoch));
+//         let max_epoch = request.max_epoch.map(|epoch| Epoch(epoch.epoch));
+//         Ok(Self {
+//             fee_instructions,
+//             instructions,
+//             inputs,
+//             min_epoch,
+//             max_epoch,
+//         })
+//     }
+// }
+//
+// impl From<&UnsignedTransactionV1> for proto::transaction::UnsignedTransaction {
+//     fn from(transaction: &UnsignedTransactionV1) -> Self {
+//         let inputs = transaction.inputs().iter().map(Into::into).collect();
+//         let min_epoch = transaction
+//             .min_epoch()
+//             .map(|epoch| proto::common::Epoch { epoch: epoch.0 });
+//         let max_epoch = transaction
+//             .max_epoch()
+//             .map(|epoch| proto::common::Epoch { epoch: epoch.0 });
+//         let fee_instructions = transaction.fee_instructions().iter().cloned().map(Into::into).collect();
+//         let instructions = transaction.instructions().iter().cloned().map(Into::into).collect();
+//
+//         proto::transaction::UnsignedTransaction {
+//             fee_instructions,
+//             instructions,
+//             inputs,
+//             min_epoch,
+//             max_epoch,
+//         }
+//     }
+// }
 
 // -------------------------------- Instruction -------------------------------- //
 
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 ecf6d2a72..b3a842441 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
@@ -273,14 +273,17 @@ CREATE INDEX locked_block_idx_epoch ON locked_block (epoch);
 create table transactions
 (
     id                integer   not null primary key AUTOINCREMENT,
+    network           integer   not NULL,
     transaction_id    text      not null,
     fee_instructions  text      not NULL,
     instructions      text      not NULL,
-    signatures        text      not NULL,
     inputs            text      not NULL,
     filled_inputs     text      not NULL,
     resolved_inputs   text      NULL,
     resulting_outputs text      NULL,
+    signatures        text      not NULL,
+    seal_signature    text      not NULL,
+    is_seal_signer_authorized boolean not NULL,
     result            text      NULL,
     execution_time_ms bigint    NULL,
     final_decision    text      NULL,
diff --git a/dan_layer/state_store_sqlite/src/reader.rs b/dan_layer/state_store_sqlite/src/reader.rs
index b05ad1f3b..5732f0273 100644
--- a/dan_layer/state_store_sqlite/src/reader.rs
+++ b/dan_layer/state_store_sqlite/src/reader.rs
@@ -21,6 +21,7 @@ use diesel::{
     QueryDsl,
     QueryableByName,
     RunQueryDsl,
+    SelectableHelper,
     SqliteConnection,
     TextExpressionMethods,
 };
@@ -697,6 +698,7 @@ impl<'tx, TAddr: NodeAddressable + Serialize + DeserializeOwned + 'tx> StateStor
         use crate::schema::transactions;
 
         let transaction = transactions::table
+            .select(sql_models::Transaction::as_select())
             .filter(transactions::transaction_id.eq(serialize_hex(tx_id)))
             .first::<sql_models::Transaction>(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 d8d2d5199..56c091f38 100644
--- a/dan_layer/state_store_sqlite/src/schema.rs
+++ b/dan_layer/state_store_sqlite/src/schema.rs
@@ -505,14 +505,17 @@ diesel::table! {
 diesel::table! {
     transactions (id) {
         id -> Integer,
+        network -> Integer,
         transaction_id -> Text,
         fee_instructions -> Text,
         instructions -> Text,
-        signatures -> Text,
         inputs -> Text,
         filled_inputs -> Text,
         resolved_inputs -> Nullable<Text>,
         resulting_outputs -> Nullable<Text>,
+        signatures -> Text,
+        seal_signature -> Text,
+        is_seal_signer_authorized -> Bool,
         result -> Nullable<Text>,
         execution_time_ms -> Nullable<BigInt>,
         final_decision -> Nullable<Text>,
diff --git a/dan_layer/state_store_sqlite/src/sql_models/transaction.rs b/dan_layer/state_store_sqlite/src/sql_models/transaction.rs
index 574cd6cd7..ddaeec733 100644
--- a/dan_layer/state_store_sqlite/src/sql_models/transaction.rs
+++ b/dan_layer/state_store_sqlite/src/sql_models/transaction.rs
@@ -3,25 +3,28 @@
 
 use std::str::FromStr;
 
-use diesel::Queryable;
+use diesel::{Queryable, Selectable};
 use tari_dan_common_types::Epoch;
 use tari_dan_storage::{consensus_models, consensus_models::Decision, StorageError};
-use tari_transaction::UnsignedTransaction;
+use tari_transaction::{UnsealedTransactionV1, UnsignedTransactionV1};
 use time::PrimitiveDateTime;
 
-use crate::serialization::deserialize_json;
+use crate::{schema::transactions, serialization::deserialize_json};
 
-#[derive(Debug, Clone, Queryable)]
+#[derive(Debug, Clone, Queryable, Selectable)]
 pub struct Transaction {
     pub id: i32,
+    pub network: i32,
     pub transaction_id: String,
     pub fee_instructions: String,
     pub instructions: String,
-    pub signatures: String,
     pub inputs: String,
     pub filled_inputs: String,
     pub resolved_inputs: Option<String>,
     pub resulting_outputs: Option<String>,
+    pub signatures: String,
+    pub seal_signature: String,
+    pub is_seal_signer_authorized: bool,
     pub result: Option<String>,
     pub execution_time_ms: Option<i64>,
     pub final_decision: Option<String>,
@@ -55,16 +58,28 @@ impl TryFrom<Transaction> for tari_transaction::Transaction {
         let filled_inputs = deserialize_json(&value.filled_inputs)?;
         let min_epoch = value.min_epoch.map(|epoch| Epoch(epoch as u64));
         let max_epoch = value.max_epoch.map(|epoch| Epoch(epoch as u64));
+        let seal_signature = deserialize_json(&value.seal_signature)?;
+        let is_seal_signer_authorized = value.is_seal_signer_authorized;
+        let network = value.network.try_into().map_err(|_| StorageError::DecodingError {
+            operation: "TryFrom<Transaction> for tari_transaction::Transaction",
+            item: "network",
+            details: format!("Invalid network value {}", value.network),
+        })?;
 
         Ok(Self::new(
-            UnsignedTransaction {
-                fee_instructions,
-                instructions,
-                inputs,
-                min_epoch,
-                max_epoch,
-            },
-            signatures,
+            UnsealedTransactionV1::new(
+                UnsignedTransactionV1 {
+                    network,
+                    fee_instructions,
+                    instructions,
+                    inputs,
+                    min_epoch,
+                    max_epoch,
+                    is_seal_signer_authorized,
+                },
+                signatures,
+            ),
+            seal_signature,
         )
         .with_filled_inputs(filled_inputs))
     }
diff --git a/dan_layer/state_store_sqlite/src/writer.rs b/dan_layer/state_store_sqlite/src/writer.rs
index ddfe5e951..b37efa5c3 100644
--- a/dan_layer/state_store_sqlite/src/writer.rs
+++ b/dan_layer/state_store_sqlite/src/writer.rs
@@ -807,6 +807,7 @@ impl<'tx, TAddr: NodeAddressable + 'tx> StateStoreWriteTransaction for SqliteSta
         let transaction = tx_rec.transaction();
         let insert = (
             transactions::transaction_id.eq(serialize_hex(transaction.id())),
+            transactions::network.eq(i32::from(transaction.network())),
             transactions::fee_instructions.eq(serialize_json(transaction.fee_instructions())?),
             transactions::instructions.eq(serialize_json(transaction.instructions())?),
             transactions::signatures.eq(serialize_json(transaction.signatures())?),
@@ -814,6 +815,8 @@ impl<'tx, TAddr: NodeAddressable + 'tx> StateStoreWriteTransaction for SqliteSta
             transactions::filled_inputs.eq(serialize_json(transaction.filled_inputs())?),
             transactions::resolved_inputs.eq(tx_rec.resolved_inputs().map(serialize_json).transpose()?),
             transactions::resulting_outputs.eq(tx_rec.resulting_outputs().map(serialize_json).transpose()?),
+            transactions::seal_signature.eq(serialize_json(transaction.seal_signature())?),
+            transactions::is_seal_signer_authorized.eq(transaction.is_seal_signer_authorized()),
             transactions::result.eq(tx_rec.execution_result().map(serialize_json).transpose()?),
             transactions::execution_time_ms.eq(tx_rec
                 .execution_time()
diff --git a/dan_layer/storage/src/consensus_models/block.rs b/dan_layer/storage/src/consensus_models/block.rs
index 1fd05860f..12680b4aa 100644
--- a/dan_layer/storage/src/consensus_models/block.rs
+++ b/dan_layer/storage/src/consensus_models/block.rs
@@ -804,6 +804,27 @@ impl Block {
         Ok(found)
     }
 
+    /// Returns the transactions that are/will be committed by this block when this block.
+    pub fn get_committing_transactions<TTx: StateStoreReadTransaction>(
+        &self,
+        tx: &TTx,
+    ) -> Result<Vec<TransactionRecord>, StorageError> {
+        let tx_ids = self.commands().iter().filter_map(|t| t.committing()).map(|t| t.id());
+        let (found, missing) = TransactionRecord::get_any(tx, tx_ids)?;
+        if !missing.is_empty() {
+            return Err(StorageError::NotFound {
+                item: "Transaction (get_committed_transactions)",
+                key: missing
+                    .into_iter()
+                    .map(|id| id.to_string())
+                    .collect::<Vec<_>>()
+                    .join(", "),
+            });
+        }
+
+        Ok(found)
+    }
+
     pub fn get_substate_updates<TTx: StateStoreReadTransaction>(
         &self,
         tx: &TTx,
diff --git a/dan_layer/storage/src/consensus_models/block_diff.rs b/dan_layer/storage/src/consensus_models/block_diff.rs
index 09f58657f..9f3ddcede 100644
--- a/dan_layer/storage/src/consensus_models/block_diff.rs
+++ b/dan_layer/storage/src/consensus_models/block_diff.rs
@@ -43,7 +43,11 @@ impl BlockDiff {
                 .changes
                 .into_iter()
                 // Commit all substates included in this shard. Every involved validator commits the transaction receipt.
-                .filter(|change| change.versioned_substate_id().substate_id.is_transaction_receipt() || info.includes_substate_address(&change.to_substate_address()))
+                .filter(|change|
+                    change.versioned_substate_id().substate_id.is_published_template() ||
+                        change.versioned_substate_id().substate_id.is_transaction_receipt() ||
+                        info.includes_substate_address(&change.to_substate_address())
+                )
                 .collect(),
         }
     }
diff --git a/dan_layer/storage/src/consensus_models/transaction.rs b/dan_layer/storage/src/consensus_models/transaction.rs
index bab345050..2abd14037 100644
--- a/dan_layer/storage/src/consensus_models/transaction.rs
+++ b/dan_layer/storage/src/consensus_models/transaction.rs
@@ -301,6 +301,9 @@ impl TransactionRecord {
         tx_ids: I,
     ) -> Result<(Vec<Self>, HashSet<TransactionId>), StorageError> {
         let mut tx_ids = tx_ids.into_iter().copied().collect::<HashSet<_>>();
+        if tx_ids.is_empty() {
+            return Ok((vec![], tx_ids));
+        }
         let recs = tx.transactions_get_any(tx_ids.iter())?;
         for rec in &recs {
             tx_ids.remove(rec.transaction.id());
diff --git a/dan_layer/template_test_tooling/src/template_test.rs b/dan_layer/template_test_tooling/src/template_test.rs
index 2b6791bcb..535664235 100644
--- a/dan_layer/template_test_tooling/src/template_test.rs
+++ b/dan_layer/template_test_tooling/src/template_test.rs
@@ -396,8 +396,7 @@ impl TemplateTest {
                 .call_method(test_faucet_component(), "take_free_coins", args![])
                 .put_last_instruction_output_on_workspace("bucket")
                 .create_account_with_bucket(public_key, "bucket")
-                .sign(&secret_key)
-                .build(),
+                .build_and_seal(&secret_key),
             vec![owner_proof.clone()],
         );
 
@@ -426,8 +425,7 @@ impl TemplateTest {
                 .call_method(test_faucet_component(), "take_free_coins_custom", args![amount])
                 .put_last_instruction_output_on_workspace("bucket")
                 .create_account_with_bucket(public_key.clone(), "bucket")
-                .sign(&secret_key)
-                .build(),
+                .build_and_seal(&secret_key),
             vec![owner_proof.clone()],
         );
 
@@ -461,8 +459,7 @@ impl TemplateTest {
         let transaction = Transaction::builder()
             .with_fee_instructions(fee_instructions)
             .with_instructions(instructions)
-            .sign(&self.secret_key)
-            .build();
+            .build_and_seal(&self.secret_key);
 
         self.try_execute(transaction, proofs)
     }
diff --git a/dan_layer/wallet/sdk/src/apis/confidential_transfer.rs b/dan_layer/wallet/sdk/src/apis/confidential_transfer.rs
index a56e51b8e..eded8f3ab 100644
--- a/dan_layer/wallet/sdk/src/apis/confidential_transfer.rs
+++ b/dan_layer/wallet/sdk/src/apis/confidential_transfer.rs
@@ -465,7 +465,7 @@ where
             builder = builder.drop_all_proofs_in_workspace();
         }
 
-        let transaction = builder.sign(&account_secret.key).build();
+        let transaction = builder.build_and_seal(&account_secret.key);
 
         self.outputs_api
             .proofs_set_transaction_hash(inputs_to_spend.proof_id, *transaction.id())?;
diff --git a/dan_layer/wallet/storage_sqlite/Cargo.toml b/dan_layer/wallet/storage_sqlite/Cargo.toml
index 3a8808465..48c69c45f 100644
--- a/dan_layer/wallet/storage_sqlite/Cargo.toml
+++ b/dan_layer/wallet/storage_sqlite/Cargo.toml
@@ -21,7 +21,7 @@ tari_dan_storage = { workspace = true }
 
 bigdecimal = { workspace = true }
 chrono = { workspace = true }
-diesel = { workspace = true, features = ["default", "sqlite", "chrono"] }
+diesel = { workspace = true, features = ["default", "sqlite", "chrono", "numeric"] }
 diesel_migrations = { workspace = true }
 log = { workspace = true }
 serde = { workspace = true, default-features = true }
diff --git a/dan_layer/wallet/storage_sqlite/migrations/2023-02-08-122514_initial/up.sql b/dan_layer/wallet/storage_sqlite/migrations/2023-02-08-122514_initial/up.sql
index e5172360d..2897bb20f 100644
--- a/dan_layer/wallet/storage_sqlite/migrations/2023-02-08-122514_initial/up.sql
+++ b/dan_layer/wallet/storage_sqlite/migrations/2023-02-08-122514_initial/up.sql
@@ -30,21 +30,24 @@ CREATE UNIQUE INDEX config_uniq_key on config (key);
 -- Transaction
 CREATE TABLE transactions
 (
-    id               INTEGER  NOT NULL PRIMARY KEY AUTOINCREMENT,
-    hash             TEXT     NOT NULL,
-    instructions     TEXT     NOT NULL,
-    signatures       TEXT     NOT NULL,
-    fee_instructions TEXT     NOT NULL,
-    inputs           TEXT     NOT NULL,
-    result           TEXT     NULL,
-    qcs              TEXT     NULL,
-    final_fee        BIGINT   NULL,
-    status           TEXT     NOT NULL,
-    dry_run          BOOLEAN  NOT NULL,
-    min_epoch        BIGINT   NULL,
-    max_epoch        BIGINT   NULL,
-    created_at       DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
-    updated_at       DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+    id                        INTEGER  NOT NULL PRIMARY KEY AUTOINCREMENT,
+    hash                      TEXT     NOT NULL,
+    network                   INTEGER  NOT NULL,
+    instructions              TEXT     NOT NULL,
+    fee_instructions          TEXT     NOT NULL,
+    inputs                    TEXT     NOT NULL,
+    signatures                TEXT     NOT NULL,
+    seal_signature            TEXT     NOT NULL,
+    is_seal_signer_authorized BOOLEAN  NOT NULL,
+    result                    TEXT     NULL,
+    qcs                       TEXT     NULL,
+    final_fee                 BIGINT   NULL,
+    status                    TEXT     NOT NULL,
+    dry_run                   BOOLEAN  NOT NULL,
+    min_epoch                 BIGINT   NULL,
+    max_epoch                 BIGINT   NULL,
+    created_at                DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    updated_at                DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
 );
 
 CREATE UNIQUE INDEX transactions_uniq_hash ON transactions (hash);
diff --git a/dan_layer/wallet/storage_sqlite/src/models/transaction.rs b/dan_layer/wallet/storage_sqlite/src/models/transaction.rs
index 55c256d53..085a95ffc 100644
--- a/dan_layer/wallet/storage_sqlite/src/models/transaction.rs
+++ b/dan_layer/wallet/storage_sqlite/src/models/transaction.rs
@@ -9,7 +9,7 @@ use tari_dan_wallet_sdk::{
     models::{TransactionStatus, WalletTransaction},
     storage::WalletStorageError,
 };
-use tari_transaction::UnsignedTransaction;
+use tari_transaction::{UnsealedTransactionV1, UnsignedTransactionV1};
 
 use crate::{schema::transactions, serialization::deserialize_json};
 
@@ -18,10 +18,13 @@ use crate::{schema::transactions, serialization::deserialize_json};
 pub struct Transaction {
     pub id: i32,
     pub hash: String,
+    pub network: i32,
     pub instructions: String,
-    pub signatures: String,
     pub fee_instructions: String,
     pub inputs: String,
+    pub signatures: String,
+    pub seal_signature: String,
+    pub is_seal_signer_authorized: bool,
     pub result: Option<String>,
     pub qcs: Option<String>,
     pub final_fee: Option<i64>,
@@ -41,17 +44,27 @@ impl Transaction {
     pub fn try_into_wallet_transaction(self) -> Result<WalletTransaction, WalletStorageError> {
         let signatures = deserialize_json(&self.signatures)?;
         let inputs = deserialize_json(&self.inputs)?;
+        let seal_signature = deserialize_json(&self.seal_signature)?;
 
         Ok(WalletTransaction {
             transaction: tari_transaction::Transaction::new(
-                UnsignedTransaction {
-                    fee_instructions: deserialize_json(&self.fee_instructions)?,
-                    instructions: deserialize_json(&self.instructions)?,
-                    inputs,
-                    min_epoch: self.min_epoch.map(|epoch| Epoch(epoch as u64)),
-                    max_epoch: self.max_epoch.map(|epoch| Epoch(epoch as u64)),
-                },
-                signatures,
+                UnsealedTransactionV1::new(
+                    UnsignedTransactionV1 {
+                        network: self.network.try_into().map_err(|_| WalletStorageError::DecodingError {
+                            operation: "transaction_get",
+                            item: "network",
+                            details: format!("Invalid network value {}", self.network),
+                        })?,
+                        fee_instructions: deserialize_json(&self.fee_instructions)?,
+                        instructions: deserialize_json(&self.instructions)?,
+                        inputs,
+                        min_epoch: self.min_epoch.map(|epoch| Epoch(epoch as u64)),
+                        max_epoch: self.max_epoch.map(|epoch| Epoch(epoch as u64)),
+                        is_seal_signer_authorized: true,
+                    },
+                    signatures,
+                ),
+                seal_signature,
             ),
             status: TransactionStatus::from_str(&self.status).map_err(|e| WalletStorageError::DecodingError {
                 operation: "transaction_get",
diff --git a/dan_layer/wallet/storage_sqlite/src/schema.rs b/dan_layer/wallet/storage_sqlite/src/schema.rs
index a72aee550..4785a8f33 100644
--- a/dan_layer/wallet/storage_sqlite/src/schema.rs
+++ b/dan_layer/wallet/storage_sqlite/src/schema.rs
@@ -104,10 +104,13 @@ diesel::table! {
     transactions (id) {
         id -> Integer,
         hash -> Text,
+        network -> Integer,
         instructions -> Text,
-        signatures -> Text,
         fee_instructions -> Text,
         inputs -> Text,
+        signatures -> Text,
+        seal_signature -> Text,
+        is_seal_signer_authorized -> Bool,
         result -> Nullable<Text>,
         qcs -> Nullable<Text>,
         final_fee -> Nullable<BigInt>,
diff --git a/dan_layer/wallet/storage_sqlite/src/writer.rs b/dan_layer/wallet/storage_sqlite/src/writer.rs
index ec5fc6cc9..732702e3e 100644
--- a/dan_layer/wallet/storage_sqlite/src/writer.rs
+++ b/dan_layer/wallet/storage_sqlite/src/writer.rs
@@ -275,9 +275,12 @@ impl WalletStoreWriter for WriteTransaction<'_> {
         diesel::insert_into(transactions::table)
             .values((
                 transactions::hash.eq(transaction.id().to_string()),
+                transactions::network.eq(i32::from(transaction.network())),
                 transactions::fee_instructions.eq(serialize_json(transaction.fee_instructions())?),
                 transactions::instructions.eq(serialize_json(transaction.instructions())?),
                 transactions::signatures.eq(serialize_json(transaction.signatures())?),
+                transactions::seal_signature.eq(serialize_json(transaction.seal_signature())?),
+                transactions::is_seal_signer_authorized.eq(transaction.is_seal_signer_authorized()),
                 transactions::inputs.eq(serialize_json(transaction.inputs())?),
                 transactions::status.eq(TransactionStatus::New.as_key_str()),
                 transactions::required_substates.eq(serialize_json(&required_substates)?),
diff --git a/dan_layer/wallet/storage_sqlite/tests/transaction.rs b/dan_layer/wallet/storage_sqlite/tests/transaction.rs
index 9d421f062..3e7eb1f47 100644
--- a/dan_layer/wallet/storage_sqlite/tests/transaction.rs
+++ b/dan_layer/wallet/storage_sqlite/tests/transaction.rs
@@ -11,7 +11,7 @@ use tari_dan_wallet_storage_sqlite::SqliteWalletStore;
 use tari_transaction::{Transaction, TransactionId};
 
 fn build_transaction() -> Transaction {
-    Transaction::builder().sign(&PrivateKey::default()).build()
+    Transaction::builder().build_and_seal(&PrivateKey::default())
 }
 
 #[test]
diff --git a/utilities/tariswap_test_bench/src/accounts.rs b/utilities/tariswap_test_bench/src/accounts.rs
index 6abe2ad2f..8317e9b04 100644
--- a/utilities/tariswap_test_bench/src/accounts.rs
+++ b/utilities/tariswap_test_bench/src/accounts.rs
@@ -37,8 +37,7 @@ impl Runner {
                 SubstateRequirement::unversioned(XTR_FAUCET_COMPONENT_ADDRESS),
                 SubstateRequirement::unversioned(XTR_FAUCET_VAULT_ADDRESS),
             ])
-            .sign(&key.key)
-            .build();
+            .build_and_seal(&key.key);
 
         let finalize = self.submit_transaction_and_wait(transaction).await?;
         let diff = finalize.result.accept().unwrap();
@@ -95,8 +94,7 @@ impl Runner {
                 SubstateRequirement::unversioned(pay_fee_vault.address),
                 SubstateRequirement::unversioned(pay_fee_vault.resource_address),
             ])
-            .sign(&key.key)
-            .build();
+            .build_and_seal(&key.key);
 
         let finalize = self.submit_transaction_and_wait(transaction).await?;
         let diff = finalize.result.accept().unwrap();
@@ -167,8 +165,7 @@ impl Runner {
                 SubstateRequirement::unversioned(fee_vault.account_address),
                 SubstateRequirement::unversioned(fee_vault.address),
             ])
-            .sign(&key.key)
-            .build();
+            .build_and_seal(&key.key);
 
         let result = self.submit_transaction_and_wait(transaction).await?;
 
diff --git a/utilities/tariswap_test_bench/src/faucet.rs b/utilities/tariswap_test_bench/src/faucet.rs
index a3c53690e..525d87eee 100644
--- a/utilities/tariswap_test_bench/src/faucet.rs
+++ b/utilities/tariswap_test_bench/src/faucet.rs
@@ -36,8 +36,8 @@ impl Runner {
                 SubstateRequirement::unversioned(fee_vault.address.clone()),
                 SubstateRequirement::unversioned(fee_vault.resource_address),
             ])
-            .sign(&key.key)
-            .build();
+            .with_authorized_seal_signer()
+            .build_and_seal(&key.key);
 
         let finalize = self.submit_transaction_and_wait(transaction).await?;
         let diff = finalize.result.accept().unwrap();
diff --git a/utilities/tariswap_test_bench/src/tariswap.rs b/utilities/tariswap_test_bench/src/tariswap.rs
index 4c6299d65..5e46bc88d 100644
--- a/utilities/tariswap_test_bench/src/tariswap.rs
+++ b/utilities/tariswap_test_bench/src/tariswap.rs
@@ -4,6 +4,7 @@
 use std::collections::HashMap;
 
 use log::info;
+use tari_crypto::{keys::PublicKey, ristretto::RistrettoPublicKey};
 use tari_dan_common_types::{optional::Optional, SubstateRequirement};
 use tari_dan_wallet_sdk::{apis::key_manager::TRANSACTION_BRANCH, models::Account};
 use tari_engine_types::indexed_value::decode_value_at_path;
@@ -30,32 +31,34 @@ impl Runner {
         num_tariswaps: usize,
     ) -> anyhow::Result<Vec<TariSwap>> {
         let key = self.sdk.key_manager_api().derive_key(TRANSACTION_BRANCH, 0)?;
-        let mut builder = Transaction::builder().fee_transaction_pay_from_component(
-            in_account.address.as_component_address().unwrap(),
-            Amount(1000 * num_tariswaps as i64),
-        );
-        for _ in 0..num_tariswaps {
-            builder = builder.call_function(self.tariswap_template.address, "new", args![
-                XTR,
-                faucet.resource_address,
-                Amount(1)
-            ]);
-        }
 
         let fee_vault = self
             .sdk
             .accounts_api()
             .get_vault_by_resource(&in_account.address, &XTR)?;
 
-        let transaction = builder
+        let transaction = Transaction::builder()
+            .fee_transaction_pay_from_component(
+                in_account.address.as_component_address().unwrap(),
+                Amount(1000 * num_tariswaps as i64),
+            )
+            .then(|mut builder| {
+                for _ in 0..num_tariswaps {
+                    builder = builder.call_function(self.tariswap_template.address, "new", args![
+                        XTR,
+                        faucet.resource_address,
+                        Amount(1)
+                    ]);
+                }
+                builder
+            })
             .with_inputs([
                 SubstateRequirement::unversioned(in_account.address.clone()),
                 SubstateRequirement::unversioned(fee_vault.address.clone()),
                 SubstateRequirement::unversioned(XTR),
                 SubstateRequirement::unversioned(faucet.resource_address),
             ])
-            .sign(&key.key)
-            .build();
+            .build_and_seal(&key.key);
 
         let finalize = self.submit_transaction_and_wait(transaction).await?;
         let diff = finalize.result.accept().unwrap();
@@ -95,6 +98,7 @@ impl Runner {
             .key_manager_api()
             .derive_key(TRANSACTION_BRANCH, primary_account.key_index)?;
         let mut tx_ids = Vec::with_capacity(200);
+        let primary_account_pk = RistrettoPublicKey::from_secret_key(&primary_account_key.key);
 
         for i in 0..5 {
             for (i, tariswap) in tariswaps.iter().enumerate().skip(i * 200).take(200) {
@@ -144,9 +148,14 @@ impl Runner {
                     .call_method(account.address.as_component_address().unwrap(), "deposit", args![
                         Workspace("lp")
                     ])
-                    .sign(&primary_account_key.key)
-                    .sign(&key.key)
-                    .build();
+                    .with_authorized_seal_signer()
+                    .add_signature(&primary_account_pk, &key.key)
+                    .build_and_seal(&primary_account_key.key);
+
+                assert!(
+                    transaction.verify_all_signatures(),
+                    "Transaction signature verification failed"
+                );
 
                 tx_ids.push((
                     account.address.clone(),
@@ -200,6 +209,7 @@ impl Runner {
             .sdk
             .key_manager_api()
             .derive_key(TRANSACTION_BRANCH, primary_account.key_index)?;
+        let primary_account_pk = RistrettoPublicKey::from_secret_key(&primary_account_key.key);
 
         let mut tx_ids = vec![];
         // Swap XTR for faucet
@@ -255,9 +265,9 @@ impl Runner {
                     .call_method(account.address.as_component_address().unwrap(), "deposit", args![
                         Workspace("swapped")
                     ])
-                    .sign(&primary_account_key.key)
-                    .sign(&key.key)
-                    .build();
+                    .with_authorized_seal_signer()
+                    .add_signature(&primary_account_pk, &key.key)
+                    .build_and_seal(&primary_account_key.key);
 
                 tx_ids.push(self.submit_transaction(transaction).await?);
             }
@@ -321,8 +331,7 @@ impl Runner {
                     .call_method(account.address.as_component_address().unwrap(), "deposit", args![
                         Workspace("swapped")
                     ])
-                    .sign(&key.key)
-                    .build();
+                    .build_and_seal(&key.key);
 
                 tx_ids.push(self.submit_transaction(transaction).await?);
             }
diff --git a/utilities/transaction_generator/src/transaction_builders/free_coins.rs b/utilities/transaction_generator/src/transaction_builders/free_coins.rs
index efd5306bb..c863186a1 100644
--- a/utilities/transaction_generator/src/transaction_builders/free_coins.rs
+++ b/utilities/transaction_generator/src/transaction_builders/free_coins.rs
@@ -35,6 +35,6 @@ pub fn builder(_: u64) -> Transaction {
             SubstateRequirement::unversioned(XTR_FAUCET_COMPONENT_ADDRESS),
             SubstateRequirement::unversioned(XTR_FAUCET_VAULT_ADDRESS),
         ])
-        .sign(&signer_secret_key)
-        .build()
+        .with_authorized_seal_signer()
+        .build_and_seal(&signer_secret_key)
 }
diff --git a/utilities/transaction_generator/src/transaction_builders/manifest.rs b/utilities/transaction_generator/src/transaction_builders/manifest.rs
index 4b5920b8a..a0eaace28 100644
--- a/utilities/transaction_generator/src/transaction_builders/manifest.rs
+++ b/utilities/transaction_generator/src/transaction_builders/manifest.rs
@@ -22,7 +22,7 @@ pub fn builder<P: AsRef<Path>>(
         Transaction::builder()
             .with_fee_instructions(instructions.fee_instructions.clone())
             .with_instructions(instructions.instructions.clone())
-            .sign(&signer_secret_key)
-            .build()
+            .with_authorized_seal_signer()
+            .build_and_seal(&signer_secret_key)
     }))
 }
diff --git a/utilities/transaction_generator/src/transaction_writer.rs b/utilities/transaction_generator/src/transaction_writer.rs
index 4120228c0..032e84030 100644
--- a/utilities/transaction_generator/src/transaction_writer.rs
+++ b/utilities/transaction_generator/src/transaction_writer.rs
@@ -8,7 +8,7 @@ use indexmap::IndexSet;
 use rayon::iter::{ParallelBridge, ParallelIterator};
 use serde::{Deserialize, Serialize};
 use tari_dan_common_types::VersionedSubstateId;
-use tari_transaction::{Transaction, TransactionSignature, UnsignedTransaction};
+use tari_transaction::{Transaction, TransactionSealSignature, UnsealedTransactionV1};
 
 use crate::BoxedTransactionBuilder;
 
@@ -52,8 +52,8 @@ pub fn write_transactions<W: Write>(
 // TODO: This hack can be removed if/when we remove #[serde(flatten)] from Transaction
 #[derive(Serialize, Deserialize)]
 pub struct FixBincodeTransaction {
-    transaction: UnsignedTransaction,
-    signatures: Vec<TransactionSignature>,
+    transaction: UnsealedTransactionV1,
+    seal_signature: TransactionSealSignature,
     filled_inputs: IndexSet<VersionedSubstateId>,
 }
 
@@ -62,19 +62,19 @@ impl FixBincodeTransaction {
     pub fn into_transaction(self) -> Transaction {
         let FixBincodeTransaction {
             transaction,
-            signatures,
+            seal_signature,
             filled_inputs,
         } = self;
-        Transaction::new(transaction, signatures).with_filled_inputs(filled_inputs)
+        Transaction::new(transaction, seal_signature).with_filled_inputs(filled_inputs)
     }
 }
 
 impl From<Transaction> for FixBincodeTransaction {
     fn from(value: Transaction) -> Self {
-        let (transaction, signatures, filled_inputs) = value.into_parts();
+        let (transaction, seal_signature, filled_inputs) = value.into_parts();
         Self {
             transaction,
-            signatures,
+            seal_signature,
             filled_inputs,
         }
     }