From b98b1f8c08ae924bb337431ac93c0511570a751b Mon Sep 17 00:00:00 2001
From: Stan Bondi <sdbondi@users.noreply.github.com>
Date: Thu, 27 Jun 2024 12:49:01 +0400
Subject: [PATCH] feat(transaction)!: allow multiple signers (#1053)

Description
---
Allow multiple signers for a transaction

Motivation and Context
---
This enables many use cases including paying for another user's fees
(gasless) and invoking two or more components owned by different public
keys in the same transaction.

It is possible for a party to remove all signatures but one and still
have a valid transaction. In future, we'll add a final signature that
includes all signatures in the preimage.

How Has This Been Tested?
---
Manually. TODO: Multiple signer integration test

What process can a PR reviewer use to test or verify this change?
---
Submit transactions requiring badges from multiple public keys

Breaking Changes
---

- [ ] None
- [x] Requires data directory to be deleted
- [ ] Other - Please specify

BREAKING CHANGE: wallet database changed, transaction struct changed
---
 .../src/transaction_executor.rs               |  19 +-
 .../routes/Transactions/FeeInstructions.tsx   | 105 ++--
 .../Transactions/TransactionDetails.tsx       | 585 +++++++++---------
 .../src/utils/json_rpc.tsx                    | 228 +++----
 .../src/p2p/services/mempool/error.rs         |   2 +
 .../mempool/validators/before/signature.rs    |   9 +-
 .../src/substate_resolver.rs                  |  27 +-
 .../src/transaction_processor.rs              | 110 ----
 bindings/src/types/Transaction.ts             |   4 +-
 bindings/src/types/UnsignedTransaction.ts     |   2 -
 dan_layer/engine/src/transaction/processor.rs |  14 +-
 dan_layer/engine/tests/account.rs             |  28 +
 dan_layer/p2p/proto/transaction.proto         |  16 +-
 dan_layer/p2p/src/conversions/common.rs       |   4 +-
 dan_layer/p2p/src/conversions/transaction.rs  |  80 ++-
 .../up.sql                                    |   2 +-
 dan_layer/state_store_sqlite/src/reader.rs    |   2 +-
 dan_layer/state_store_sqlite/src/schema.rs    |   2 +-
 .../src/sql_models/transaction.rs             |  23 +-
 dan_layer/state_store_sqlite/src/writer.rs    |   4 +-
 dan_layer/template_lib/src/args/arg.rs        |   8 +-
 dan_layer/transaction/src/builder.rs          |  77 +--
 dan_layer/transaction/src/lib.rs              |   2 +
 dan_layer/transaction/src/substate.rs         | 260 ++++++++
 dan_layer/transaction/src/transaction.rs      | 347 ++---------
 .../transaction/src/unsigned_transaction.rs   | 126 +++-
 .../2023-02-08-122514_initial/up.sql          |  31 +-
 .../storage_sqlite/src/models/transaction.rs  |  31 +-
 dan_layer/wallet/storage_sqlite/src/schema.rs |   3 +-
 dan_layer/wallet/storage_sqlite/src/writer.rs |   3 +-
 .../tests/features/wallet_daemon.feature      |  26 +-
 integration_tests/tests/steps/indexer.rs      |  11 +
 integration_tests/tests/steps/miner.rs        |   2 +-
 integration_tests/tests/steps/mod.rs          |   1 +
 integration_tests/tests/steps/network.rs      |  46 ++
 .../tests/steps/validator_node.rs             |   4 +-
 integration_tests/tests/steps/wallet.rs       |   2 +-
 37 files changed, 1191 insertions(+), 1055 deletions(-)
 delete mode 100644 applications/tari_validator_node/src/transaction_processor.rs
 create mode 100644 dan_layer/transaction/src/substate.rs
 create mode 100644 integration_tests/tests/steps/network.rs

diff --git a/applications/tari_dan_app_utilities/src/transaction_executor.rs b/applications/tari_dan_app_utilities/src/transaction_executor.rs
index 03de46dc2..d29ec0b06 100644
--- a/applications/tari_dan_app_utilities/src/transaction_executor.rs
+++ b/applications/tari_dan_app_utilities/src/transaction_executor.rs
@@ -108,10 +108,15 @@ where TTemplateProvider: TemplateProvider<Template = LoadedTemplate>
         virtual_substates: VirtualSubstates,
     ) -> Result<ExecutionOutput, Self::Error> {
         let timer = Instant::now();
-        // Include ownership token for the signers of this in the auth scope
-        let owner_token = get_auth_token(transaction.signer_public_key());
+        // Include signature public key badges for all transaction signers in the initial auth scope
+        // NOTE: we assume all signatures have already been validated.
+        let initial_ownership_proofs = transaction
+            .signatures()
+            .iter()
+            .map(|sig| public_key_to_fungible_address(sig.public_key()))
+            .collect();
         let auth_params = AuthParams {
-            initial_ownership_proofs: vec![owner_token],
+            initial_ownership_proofs,
         };
 
         let initial_cost = 0;
@@ -152,10 +157,10 @@ where TTemplateProvider: TemplateProvider<Template = LoadedTemplate>
     }
 }
 
-fn get_auth_token(public_key: &PublicKey) -> NonFungibleAddress {
-    let public_key =
-        RistrettoPublicKeyBytes::from_bytes(public_key.as_bytes()).expect("Expected public key to be 32 bytes");
-    NonFungibleAddress::from_public_key(public_key)
+fn public_key_to_fungible_address(public_key: &PublicKey) -> NonFungibleAddress {
+    RistrettoPublicKeyBytes::from_bytes(public_key.as_bytes())
+        .expect("Expected public key to be 32 bytes")
+        .to_non_fungible_address()
 }
 
 #[derive(Debug, thiserror::Error)]
diff --git a/applications/tari_dan_wallet_web_ui/src/routes/Transactions/FeeInstructions.tsx b/applications/tari_dan_wallet_web_ui/src/routes/Transactions/FeeInstructions.tsx
index 83d2340b4..b7433c704 100644
--- a/applications/tari_dan_wallet_web_ui/src/routes/Transactions/FeeInstructions.tsx
+++ b/applications/tari_dan_wallet_web_ui/src/routes/Transactions/FeeInstructions.tsx
@@ -20,62 +20,63 @@
 //  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 { useState } from "react";
-import { TableContainer, Table, TableRow, TableBody, Collapse } from "@mui/material";
-import { DataTableCell, AccordionIconButton } from "../../Components/StyledComponents";
+import {useState} from "react";
+import {TableContainer, Table, TableRow, TableBody, Collapse} from "@mui/material";
+import {DataTableCell, AccordionIconButton} from "../../Components/StyledComponents";
 import KeyboardArrowDownIcon from "@mui/icons-material/KeyboardArrowDown";
 import KeyboardArrowUpIcon from "@mui/icons-material/KeyboardArrowUp";
 import CodeBlockExpand from "../../Components/CodeBlock";
-import { useTheme } from "@mui/material/styles";
-import type { Instruction } from "@tariproject/typescript-bindings";
+import {useTheme} from "@mui/material/styles";
+import type {Instruction, TransactionSignature} from "@tariproject/typescript-bindings";
 
-function RowData({ title, data }: { title: string; data: Instruction }, index: number) {
-  const [open, setOpen] = useState(false);
-  const theme = useTheme();
-  return (
-    <>
-      <TableRow key={`${index}-1`}>
-        <DataTableCell width={90} sx={{ borderBottom: "none", textAlign: "center" }}>
-          <AccordionIconButton
-            aria-label="expand row"
-            size="small"
-            onClick={() => {
-              setOpen(!open);
-            }}
-          >
-            {open ? <KeyboardArrowUpIcon /> : <KeyboardArrowDownIcon />}
-          </AccordionIconButton>
-        </DataTableCell>
-        <DataTableCell>{title}</DataTableCell>
-      </TableRow>
-      <TableRow key={`${index}-2`}>
-        <DataTableCell
-          style={{
-            paddingBottom: theme.spacing(1),
-            paddingTop: 0,
-            borderBottom: "none",
-          }}
-          colSpan={2}
-        >
-          <Collapse in={open} timeout="auto" unmountOnExit>
-            <CodeBlockExpand title={title} content={data} />
-          </Collapse>
-        </DataTableCell>
-      </TableRow>
-    </>
-  );
+function RowData({title, data}: { title: string; data: Instruction }, index: number) {
+    const [open, setOpen] = useState(false);
+    const theme = useTheme();
+    return (
+        <>
+            <TableRow key={`${index}-1`}>
+                <DataTableCell width={90} sx={{borderBottom: "none", textAlign: "center"}}>
+                    <AccordionIconButton
+                        aria-label="expand row"
+                        size="small"
+                        onClick={() => {
+                            setOpen(!open);
+                        }}
+                    >
+                        {open ? <KeyboardArrowUpIcon/> : <KeyboardArrowDownIcon/>}
+                    </AccordionIconButton>
+                </DataTableCell>
+                <DataTableCell>{title}</DataTableCell>
+            </TableRow>
+            <TableRow key={`${index}-2`}>
+                <DataTableCell
+                    style={{
+                        paddingBottom: theme.spacing(1),
+                        paddingTop: 0,
+                        borderBottom: "none",
+                    }}
+                    colSpan={2}
+                >
+                    <Collapse in={open} timeout="auto" unmountOnExit>
+                        <CodeBlockExpand title={title} content={data}/>
+                    </Collapse>
+                </DataTableCell>
+            </TableRow>
+        </>
+    );
 }
 
-export default function FeeInstructions({ data }: { data: Array<Instruction> }) {
-  return (
-    <TableContainer>
-      <Table>
-        <TableBody>
-          {data.map((item: Instruction, index: number) => {
-            return <RowData key={index} title={Object.keys(item)[0]} data={item} />;
-          })}
-        </TableBody>
-      </Table>
-    </TableContainer>
-  );
+export default function FeeInstructions({data}: { data: Array<Instruction> }) {
+    return (
+        <TableContainer>
+            <Table>
+                <TableBody>
+                    {data.map((item: Instruction, index: number) => {
+                        return <RowData key={index} title={Object.keys(item)[0]} data={item}/>;
+                    })}
+                </TableBody>
+            </Table>
+        </TableContainer>
+    );
 }
+
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 b9c3f9b4b..336570ff2 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
@@ -20,14 +20,14 @@
 //  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 { useState } from "react";
-import { useLocation } from "react-router-dom";
-import { useTransactionDetails } from "../../api/hooks/useTransactions";
-import { Accordion, AccordionDetails, AccordionSummary } from "../../Components/Accordion";
-import { Grid, Table, TableContainer, TableBody, TableRow, TableCell, Button, Fade, Alert } from "@mui/material";
+import {useState} from "react";
+import {useLocation} from "react-router-dom";
+import {useTransactionDetails} from "../../api/hooks/useTransactions";
+import {Accordion, AccordionDetails, AccordionSummary} from "../../Components/Accordion";
+import {Grid, Table, TableContainer, TableBody, TableRow, TableCell, Button, Fade, Alert} from "@mui/material";
 import Typography from "@mui/material/Typography";
-import { saveAs } from "file-saver";
-import { DataTableCell, StyledPaper } from "../../Components/StyledComponents";
+import {saveAs} from "file-saver";
+import {DataTableCell, StyledPaper} from "../../Components/StyledComponents";
 import PageHeading from "../../Components/PageHeading";
 import Events from "./Events";
 import Logs from "./Logs";
@@ -39,294 +39,321 @@ import KeyboardArrowDownIcon from "@mui/icons-material/KeyboardArrowDown";
 import KeyboardArrowUpIcon from "@mui/icons-material/KeyboardArrowUp";
 import Loading from "../../Components/Loading";
 import Error from "../../Components/Error";
-import type { FinalizeResult, RejectReason, TransactionResult } from "@tariproject/typescript-bindings";
-import { getRejectReasonFromTransactionResult, rejectReasonToString } from "@tariproject/typescript-bindings";
+import type {
+    FinalizeResult,
+    RejectReason,
+    TransactionResult,
+    TransactionSignature
+} from "@tariproject/typescript-bindings";
+import {getRejectReasonFromTransactionResult, rejectReasonToString} from "@tariproject/typescript-bindings";
 
 export default function TransactionDetails() {
-  const [expandedPanels, setExpandedPanels] = useState<string[]>([]);
-  const location = useLocation();
-  const { data, isLoading, isError, error } = useTransactionDetails(location.pathname.split("/")[2]);
+    const [expandedPanels, setExpandedPanels] = useState<string[]>([]);
+    const location = useLocation();
+    const {data, isLoading, isError, error} = useTransactionDetails(location.pathname.split("/")[2]);
 
-  const handleChange = (panel: string) => (event: React.SyntheticEvent, isExpanded: boolean) => {
-    setExpandedPanels((prevExpandedPanels) => {
-      if (isExpanded) {
-        return [...prevExpandedPanels, panel];
-      } else {
-        return prevExpandedPanels.filter((p) => p !== panel);
-      }
-    });
-  };
+    const handleChange = (panel: string) => (event: React.SyntheticEvent, isExpanded: boolean) => {
+        setExpandedPanels((prevExpandedPanels) => {
+            if (isExpanded) {
+                return [...prevExpandedPanels, panel];
+            } else {
+                return prevExpandedPanels.filter((p) => p !== panel);
+            }
+        });
+    };
 
-  const expandAll = () => {
-    setExpandedPanels(["panel1", "panel2", "panel3", "panel4", "panel5"]);
-  };
+    const expandAll = () => {
+        setExpandedPanels(["panel1", "panel2", "panel3", "panel4", "panel5", "panel6"]);
+    };
 
-  const collapseAll = () => {
-    setExpandedPanels([]);
-  };
+    const collapseAll = () => {
+        setExpandedPanels([]);
+    };
 
-  const renderResult = (result: FinalizeResult | null) => {
-    if (result) {
-      if ("Accept" in result.result) {
-        return <span>Accepted</span>;
-      }
-      return <span>{rejectReasonToString(getRejectReasonFromTransactionResult(result.result))}</span>;
-    } else {
-      return <span>In progress</span>;
-    }
-  };
+    const renderResult = (result: FinalizeResult | null) => {
+        if (result) {
+            if ("Accept" in result.result) {
+                return <span>Accepted</span>;
+            }
+            return <span>{rejectReasonToString(getRejectReasonFromTransactionResult(result.result))}</span>;
+        } else {
+            return <span>In progress</span>;
+        }
+    };
 
-  const renderContent = () => {
-    if (isLoading) {
-      return <Loading />;
-    }
+    const renderContent = () => {
+        if (isLoading) {
+            return <Loading/>;
+        }
 
-    if (isError) {
-      return <Error message={error.message} />;
-    }
+        if (isError) {
+            return <Error message={error.message}/>;
+        }
 
-    if (!data) {
-      return null;
-    }
+        if (!data) {
+            return null;
+        }
 
-    if (data.status === "Pending") {
-      return (
-        <>
-          <Typography variant="body1" style={{ textAlign: "center" }}>
-            Transaction is still pending. Please check back later.
-          </Typography>
-        </>
-      );
-    }
+        if (data.status === "Pending") {
+            return (
+                <>
+                    <Typography variant="body1" style={{textAlign: "center"}}>
+                        Transaction is still pending. Please check back later.
+                    </Typography>
+                </>
+            );
+        }
 
-    const last_update_time = new Date(data.last_update_time);
-    const handleDownload = () => {
-      const json = JSON.stringify(data, null, 2);
-      const blob = new Blob([json], { type: "application/json" });
-      const filename = `tx-${data?.transaction?.id}.json` || "tx-unknown_id.json";
-      saveAs(blob, filename);
-    };
+        const last_update_time = new Date(data.last_update_time);
+        const handleDownload = () => {
+            const json = JSON.stringify(data, null, 2);
+            const blob = new Blob([json], {type: "application/json"});
+            const filename = `tx-${data?.transaction?.id}.json` || "tx-unknown_id.json";
+            saveAs(blob, filename);
+        };
+
+        const getTransactionFailure = (txResult: TransactionResult | undefined): string => {
+            if (txResult === undefined || "Accept" in txResult) {
+                return "No reason";
+            }
+            let reason;
+            if ("AcceptFeeRejectRest" in txResult) {
+                reason = txResult.AcceptFeeRejectRest[1];
+            } else {
+                reason = txResult.Reject;
+            }
+            const getReasonString = (x: RejectReason): string => {
+                if (typeof x === "string") {
+                    return x;
+                } else if ("ShardsNotPledged" in x) {
+                    return `ShardsNotPledged: ${x["ShardsNotPledged"]}`;
+                } else if ("ExecutionFailure" in x) {
+                    return `ExecutionFailure: ${x["ExecutionFailure"]}`;
+                } else if ("ShardPledgedToAnotherPayload" in x) {
+                    return `ShardPledgedToAnotherPayload: ${x["ShardPledgedToAnotherPayload"]}`;
+                } else if ("ShardRejected" in x) {
+                    return `ShardRejected: ${x["ShardRejected"]}`;
+                } else if ("FeesNotPaid" in x) {
+                    return `FeesNotPaid: ${x["FeesNotPaid"]}`;
+                }
+                return "Unknown reason";
+            };
+            return getReasonString(reason);
+        };
 
-    const getTransactionFailure = (txResult: TransactionResult | undefined): string => {
-      if (txResult === undefined || "Accept" in txResult) {
-        return "No reason";
-      }
-      let reason;
-      if ("AcceptFeeRejectRest" in txResult) {
-        reason = txResult.AcceptFeeRejectRest[1];
-      } else {
-        reason = txResult.Reject;
-      }
-      const getReasonString = (x: RejectReason): string => {
-        if (typeof x === "string") {
-          return x;
-        } else if ("ShardsNotPledged" in x) {
-          return `ShardsNotPledged: ${x["ShardsNotPledged"]}`;
-        } else if ("ExecutionFailure" in x) {
-          return `ExecutionFailure: ${x["ExecutionFailure"]}`;
-        } else if ("ShardPledgedToAnotherPayload" in x) {
-          return `ShardPledgedToAnotherPayload: ${x["ShardPledgedToAnotherPayload"]}`;
-        } else if ("ShardRejected" in x) {
-          return `ShardRejected: ${x["ShardRejected"]}`;
-        } else if ("FeesNotPaid" in x) {
-          return `FeesNotPaid: ${x["FeesNotPaid"]}`;
+        if (data.status === "Rejected" || data.status === "InvalidTransaction") {
+            return (
+                <>
+                    <TableContainer>
+                        <Table>
+                            <TableBody>
+                                <TableRow>
+                                    <TableCell>Transaction Hash</TableCell>
+                                    <DataTableCell>{data.transaction.id}</DataTableCell>
+                                </TableRow>
+                                <TableRow>
+                                    <TableCell>Timestamp</TableCell>
+                                    <DataTableCell>{last_update_time.toLocaleString()}</DataTableCell>
+                                </TableRow>
+                                <TableRow>
+                                    <TableCell>Status</TableCell>
+                                    <DataTableCell>
+                                        <StatusChip status={data.status}/>
+                                    </DataTableCell>
+                                </TableRow>
+                                <TableRow>
+                                    <TableCell>JSON</TableCell>
+                                    <DataTableCell>
+                                        <Button variant="outlined" onClick={handleDownload}>
+                                            Download
+                                        </Button>
+                                    </DataTableCell>
+                                </TableRow>
+                                <TableRow>
+                                    <TableCell>Reason</TableCell>
+                                    <DataTableCell>{getTransactionFailure(data?.result?.result)}</DataTableCell>
+                                </TableRow>
+                            </TableBody>
+                        </Table>
+                    </TableContainer>
+                </>
+            );
         }
-        return "Unknown reason";
-      };
-      return getReasonString(reason);
+
+        return (
+            <Fade in={!isLoading}>
+                <div>
+                    <>
+                        <TableContainer>
+                            <Table>
+                                <TableBody>
+                                    <TableRow>
+                                        <TableCell>Transaction Hash</TableCell>
+                                        <DataTableCell>{data.transaction.id}</DataTableCell>
+                                    </TableRow>
+                                    <TableRow>
+                                        <TableCell>Timestamp</TableCell>
+                                        <DataTableCell>{last_update_time.toLocaleString()}</DataTableCell>
+                                    </TableRow>
+                                    <TableRow>
+                                        <TableCell>Total Fees</TableCell>
+                                        <DataTableCell>{data?.result?.fee_receipt.total_fees_paid || 0}</DataTableCell>
+                                    </TableRow>
+                                    <TableRow>
+                                        <TableCell>Status</TableCell>
+                                        <DataTableCell>
+                                            <StatusChip status={data.status}/>
+                                        </DataTableCell>
+                                    </TableRow>
+                                    <TableRow>
+                                        <TableCell>Result</TableCell>
+                                        <DataTableCell>{renderResult(data?.result)}</DataTableCell>
+                                    </TableRow>
+                                    <TableRow>
+                                        <TableCell>JSON</TableCell>
+                                        <DataTableCell>
+                                            <Button variant="outlined" onClick={handleDownload}>
+                                                Download
+                                            </Button>
+                                        </DataTableCell>
+                                    </TableRow>
+                                    {data?.result?.result ? (
+                                        <TableRow>
+                                            <TableCell>Reason</TableCell>
+                                            <DataTableCell>{getTransactionFailure(data?.result?.result)}</DataTableCell>
+                                        </TableRow>
+                                    ) : null}
+                                </TableBody>
+                            </Table>
+                        </TableContainer>
+                        <div
+                            style={{
+                                display: "flex",
+                                justifyContent: "space-between",
+                                alignItems: "center",
+                                padding: "2rem 1rem 0.5rem 1rem",
+                            }}
+                            // className="flex-container"
+                        >
+                            <Typography variant="h5">More Info</Typography>
+                            <div
+                                style={{
+                                    display: "flex",
+                                    justifyContent: "flex-end",
+                                    gap: "1rem",
+                                }}
+                            >
+                                <Button
+                                    onClick={expandAll}
+                                    style={{
+                                        fontSize: "0.85rem",
+                                    }}
+                                    startIcon={<KeyboardArrowDownIcon/>}
+                                >
+                                    Expand All
+                                </Button>
+                                <Button
+                                    onClick={collapseAll}
+                                    style={{
+                                        fontSize: "0.85rem",
+                                    }}
+                                    startIcon={<KeyboardArrowUpIcon/>}
+                                    disabled={expandedPanels.length === 0 ? true : false}
+                                >
+                                    Collapse All
+                                </Button>
+                            </div>
+                        </div>
+                    </>
+                    <Accordion expanded={expandedPanels.includes("panel1")} onChange={handleChange("panel1")}>
+                        <AccordionSummary aria-controls="panel1bh-content" id="panel1bh-header">
+                            <Typography>Fee Instructions</Typography>
+                        </AccordionSummary>
+                        <AccordionDetails>
+                            {data.transaction?.fee_instructions?.length ? (
+                                <FeeInstructions data={data.transaction.fee_instructions}/>
+                            ) : (
+                                <span>Empty</span>
+                            )}
+                        </AccordionDetails>
+                    </Accordion>
+                    <Accordion expanded={expandedPanels.includes("panel2")} onChange={handleChange("panel2")}>
+                        <AccordionSummary aria-controls="panel2bh-content" id="panel1bh-header">
+                            <Typography>Instructions</Typography>
+                        </AccordionSummary>
+                        <AccordionDetails>
+                            {data.transaction?.instructions?.length ? (
+                                <Instructions data={data.transaction.instructions}/>
+                            ) : (
+                                <span>Empty</span>
+                            )}
+                        </AccordionDetails>
+                    </Accordion>
+                    {data.result && (
+                        <Accordion expanded={expandedPanels.includes("panel3")} onChange={handleChange("panel3")}>
+                            <AccordionSummary aria-controls="panel3bh-content" id="panel1bh-header">
+                                <Typography>Events</Typography>
+                            </AccordionSummary>
+                            <AccordionDetails>
+                                <Events data={data.result.events}/>
+                            </AccordionDetails>
+                        </Accordion>
+                    )}
+                    {data.result && (
+                        <Accordion expanded={expandedPanels.includes("panel4")} onChange={handleChange("panel4")}>
+                            <AccordionSummary aria-controls="panel4bh-content" id="panel1bh-header">
+                                <Typography>Logs</Typography>
+                            </AccordionSummary>
+                            <AccordionDetails>
+                                <Logs data={data.result.logs}/>
+                            </AccordionDetails>
+                        </Accordion>
+                    )}
+                    {data.result && (
+                        <Accordion expanded={expandedPanels.includes("panel5")} onChange={handleChange("panel5")}>
+                            <AccordionSummary aria-controls="panel5bh-content" id="panel1bh-header">
+                                <Typography>Substates</Typography>
+                            </AccordionSummary>
+                            <AccordionDetails>
+                                <Substates data={data.result.result}/>
+                            </AccordionDetails>
+                        </Accordion>
+                    )}
+                    <Accordion expanded={expandedPanels.includes("panel6")} onChange={handleChange("panel6")}>
+                        <AccordionSummary aria-controls="panel6bh-content" id="panel6bh-header">
+                            <Typography>Signers</Typography>
+                        </AccordionSummary>
+                        <AccordionDetails>
+                            {data.transaction?.signatures?.length ? (
+                                <TableContainer>
+                                    <Table>
+                                        <TableBody>
+                                            {data.transaction.signatures.map((item: TransactionSignature, i: number) => {
+                                                return <TableRow
+                                                    key={i}><DataTableCell>{item.public_key}</DataTableCell></TableRow>
+                                            })}
+                                        </TableBody>
+                                    </Table>
+                                </TableContainer>
+                            ) : (
+                                <span>Empty</span>
+                            )}
+                        </AccordionDetails>
+                    </Accordion>
+                </div>
+            </Fade>
+        );
     };
 
-    if (data.status === "Rejected" || data.status === "InvalidTransaction") {
-      return (
+    return (
         <>
-          <TableContainer>
-            <Table>
-              <TableBody>
-                <TableRow>
-                  <TableCell>Transaction Hash</TableCell>
-                  <DataTableCell>{data.transaction.id}</DataTableCell>
-                </TableRow>
-                <TableRow>
-                  <TableCell>Timestamp</TableCell>
-                  <DataTableCell>{last_update_time.toLocaleString()}</DataTableCell>
-                </TableRow>
-                <TableRow>
-                  <TableCell>Status</TableCell>
-                  <DataTableCell>
-                    <StatusChip status={data.status} />
-                  </DataTableCell>
-                </TableRow>
-                <TableRow>
-                  <TableCell>JSON</TableCell>
-                  <DataTableCell>
-                    <Button variant="outlined" onClick={handleDownload}>
-                      Download
-                    </Button>
-                  </DataTableCell>
-                </TableRow>
-                <TableRow>
-                  <TableCell>Reason</TableCell>
-                  <DataTableCell>{getTransactionFailure(data?.result?.result)}</DataTableCell>
-                </TableRow>
-              </TableBody>
-            </Table>
-          </TableContainer>
+            <Grid item xs={12} md={12} lg={12}>
+                <PageHeading>Transaction Details</PageHeading>
+            </Grid>
+            <Grid item xs={12} md={12} lg={12}>
+                <StyledPaper>{renderContent()}</StyledPaper>
+            </Grid>
         </>
-      );
-    }
-
-    return (
-      <Fade in={!isLoading}>
-        <div>
-          <>
-            <TableContainer>
-              <Table>
-                <TableBody>
-                  <TableRow>
-                    <TableCell>Transaction Hash</TableCell>
-                    <DataTableCell>{data.transaction.id}</DataTableCell>
-                  </TableRow>
-                  <TableRow>
-                    <TableCell>Timestamp</TableCell>
-                    <DataTableCell>{last_update_time.toLocaleString()}</DataTableCell>
-                  </TableRow>
-                  <TableRow>
-                    <TableCell>Total Fees</TableCell>
-                    <DataTableCell>{data?.result?.fee_receipt.total_fees_paid || 0}</DataTableCell>
-                  </TableRow>
-                  <TableRow>
-                    <TableCell>Status</TableCell>
-                    <DataTableCell>
-                      <StatusChip status={data.status} />
-                    </DataTableCell>
-                  </TableRow>
-                  <TableRow>
-                    <TableCell>Result</TableCell>
-                    <DataTableCell>{renderResult(data?.result)}</DataTableCell>
-                  </TableRow>
-                  <TableRow>
-                    <TableCell>JSON</TableCell>
-                    <DataTableCell>
-                      <Button variant="outlined" onClick={handleDownload}>
-                        Download
-                      </Button>
-                    </DataTableCell>
-                  </TableRow>
-                  {data?.result?.result ? (
-                    <TableRow>
-                      <TableCell>Reason</TableCell>
-                      <DataTableCell>{getTransactionFailure(data?.result?.result)}</DataTableCell>
-                    </TableRow>
-                  ) : null}
-                </TableBody>
-              </Table>
-            </TableContainer>
-            <div
-              style={{
-                display: "flex",
-                justifyContent: "space-between",
-                alignItems: "center",
-                padding: "2rem 1rem 0.5rem 1rem",
-              }}
-              // className="flex-container"
-            >
-              <Typography variant="h5">More Info</Typography>
-              <div
-                style={{
-                  display: "flex",
-                  justifyContent: "flex-end",
-                  gap: "1rem",
-                }}
-              >
-                <Button
-                  onClick={expandAll}
-                  style={{
-                    fontSize: "0.85rem",
-                  }}
-                  startIcon={<KeyboardArrowDownIcon />}
-                >
-                  Expand All
-                </Button>
-                <Button
-                  onClick={collapseAll}
-                  style={{
-                    fontSize: "0.85rem",
-                  }}
-                  startIcon={<KeyboardArrowUpIcon />}
-                  disabled={expandedPanels.length === 0 ? true : false}
-                >
-                  Collapse All
-                </Button>
-              </div>
-            </div>
-          </>
-          <Accordion expanded={expandedPanels.includes("panel1")} onChange={handleChange("panel1")}>
-            <AccordionSummary aria-controls="panel1bh-content" id="panel1bh-header">
-              <Typography>Fee Instructions</Typography>
-            </AccordionSummary>
-            <AccordionDetails>
-              {data.transaction?.fee_instructions.length > 0 ? (
-                <FeeInstructions data={data.transaction.fee_instructions} />
-              ) : (
-                <span>Empty</span>
-              )}
-            </AccordionDetails>
-          </Accordion>
-          <Accordion expanded={expandedPanels.includes("panel2")} onChange={handleChange("panel2")}>
-            <AccordionSummary aria-controls="panel2bh-content" id="panel1bh-header">
-              <Typography>Instructions</Typography>
-            </AccordionSummary>
-            <AccordionDetails>
-              {data.transaction?.instructions?.length > 0 ? (
-                <Instructions data={data.transaction.instructions} />
-              ) : (
-                <span>Empty</span>
-              )}
-            </AccordionDetails>
-          </Accordion>
-          {data.result && (
-            <Accordion expanded={expandedPanels.includes("panel3")} onChange={handleChange("panel3")}>
-              <AccordionSummary aria-controls="panel3bh-content" id="panel1bh-header">
-                <Typography>Events</Typography>
-              </AccordionSummary>
-              <AccordionDetails>
-                <Events data={data.result.events} />
-              </AccordionDetails>
-            </Accordion>
-          )}
-          {data.result && (
-            <Accordion expanded={expandedPanels.includes("panel4")} onChange={handleChange("panel4")}>
-              <AccordionSummary aria-controls="panel4bh-content" id="panel1bh-header">
-                <Typography>Logs</Typography>
-              </AccordionSummary>
-              <AccordionDetails>
-                <Logs data={data.result.logs} />
-              </AccordionDetails>
-            </Accordion>
-          )}
-          {data.result && (
-            <Accordion expanded={expandedPanels.includes("panel5")} onChange={handleChange("panel5")}>
-              <AccordionSummary aria-controls="panel5bh-content" id="panel1bh-header">
-                <Typography>Substates</Typography>
-              </AccordionSummary>
-              <AccordionDetails>
-                <Substates data={data.result.result} />
-              </AccordionDetails>
-            </Accordion>
-          )}
-        </div>
-      </Fade>
     );
-  };
-
-  return (
-    <>
-      <Grid item xs={12} md={12} lg={12}>
-        <PageHeading>Transaction Details</PageHeading>
-      </Grid>
-      <Grid item xs={12} md={12} lg={12}>
-        <StyledPaper>{renderContent()}</StyledPaper>
-      </Grid>
-    </>
-  );
 }
+
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 671dc5500..01fa7449e 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
@@ -21,186 +21,186 @@
 //  USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 import type {
-  AccountGetRequest,
-  AccountGetResponse,
-  AccountSetDefaultRequest,
-  AccountSetDefaultResponse,
-  AccountsCreateFreeTestCoinsRequest,
-  AccountsCreateFreeTestCoinsResponse,
-  AccountsCreateRequest,
-  AccountsCreateResponse,
-  AccountsGetBalancesRequest,
-  AccountsGetBalancesResponse,
-  AccountsListRequest,
-  AccountsListResponse,
-  AuthGetAllJwtRequest,
-  AuthGetAllJwtResponse,
-  AuthRevokeTokenRequest,
-  AuthRevokeTokenResponse,
-  ClaimBurnRequest,
-  ClaimBurnResponse,
-  ClaimValidatorFeesRequest,
-  ClaimValidatorFeesResponse,
-  ConfidentialTransferRequest,
-  ConfidentialTransferResponse,
-  ConfidentialViewVaultBalanceRequest,
-  ConfidentialViewVaultBalanceResponse,
-  KeysCreateRequest,
-  KeysCreateResponse,
-  KeysListRequest,
-  KeysListResponse,
-  KeysSetActiveRequest,
-  KeysSetActiveResponse,
-  ListAccountNftRequest,
-  ListAccountNftResponse,
-  RevealFundsRequest,
-  RevealFundsResponse,
-  SettingsGetResponse,
-  SettingsSetRequest,
-  SettingsSetResponse,
-  TransactionGetAllRequest,
-  TransactionGetAllResponse,
-  TransactionGetRequest,
-  TransactionGetResponse,
-  TransactionGetResultRequest,
-  TransactionGetResultResponse,
-  TransactionSubmitRequest,
-  TransactionSubmitResponse,
-  TransactionWaitResultRequest,
-  TransactionWaitResultResponse,
-  WebRtcStartRequest,
-  WebRtcStartResponse, AccountsTransferRequest, AccountsTransferResponse,
+    AccountGetRequest,
+    AccountGetResponse,
+    AccountSetDefaultRequest,
+    AccountSetDefaultResponse,
+    AccountsCreateFreeTestCoinsRequest,
+    AccountsCreateFreeTestCoinsResponse,
+    AccountsCreateRequest,
+    AccountsCreateResponse,
+    AccountsGetBalancesRequest,
+    AccountsGetBalancesResponse,
+    AccountsListRequest,
+    AccountsListResponse,
+    AuthGetAllJwtRequest,
+    AuthGetAllJwtResponse,
+    AuthRevokeTokenRequest,
+    AuthRevokeTokenResponse,
+    ClaimBurnRequest,
+    ClaimBurnResponse,
+    ClaimValidatorFeesRequest,
+    ClaimValidatorFeesResponse,
+    ConfidentialTransferRequest,
+    ConfidentialTransferResponse,
+    ConfidentialViewVaultBalanceRequest,
+    ConfidentialViewVaultBalanceResponse,
+    KeysCreateRequest,
+    KeysCreateResponse,
+    KeysListRequest,
+    KeysListResponse,
+    KeysSetActiveRequest,
+    KeysSetActiveResponse,
+    ListAccountNftRequest,
+    ListAccountNftResponse,
+    RevealFundsRequest,
+    RevealFundsResponse,
+    SettingsGetResponse,
+    SettingsSetRequest,
+    SettingsSetResponse,
+    TransactionGetAllRequest,
+    TransactionGetAllResponse,
+    TransactionGetRequest,
+    TransactionGetResponse,
+    TransactionGetResultRequest,
+    TransactionGetResultResponse,
+    TransactionSubmitRequest,
+    TransactionSubmitResponse,
+    TransactionWaitResultRequest,
+    TransactionWaitResultResponse,
+    WebRtcStartRequest,
+    WebRtcStartResponse, AccountsTransferRequest, AccountsTransferResponse,
 } from "@tariproject/typescript-bindings/wallet-daemon-client";
-import { WalletDaemonClient } from "@tariproject/wallet_daemon_client";
+import {WalletDaemonClient} from "@tariproject/wallet_daemon_client";
 
 
 let clientInstance: WalletDaemonClient | null = null;
 let pendingClientInstance: Promise<WalletDaemonClient> | null = null;
 let outerAddress: URL | null = null;
-const DEFAULT_WALLET_ADDRESS = new URL("http://localhost:9000");
+const DEFAULT_WALLET_ADDRESS = new URL(import.meta.env.VITE_DAEMON_JRPC_ADDRESS || "http://localhost:9000");
 
 export async function getClientAddress(): Promise<URL> {
-  try {
-    let resp = await fetch("/json_rpc_address");
-    if (resp.status === 200) {
-      return new URL(await resp.text());
+    try {
+        let resp = await fetch("/json_rpc_address");
+        if (resp.status === 200) {
+            return new URL(await resp.text());
+        }
+    } catch (e) {
+        console.warn(e);
     }
-  } catch (e) {
-    console.warn(e);
-  }
 
-  return DEFAULT_WALLET_ADDRESS;
+    return DEFAULT_WALLET_ADDRESS;
 }
 
 async function client() {
-  if (pendingClientInstance) {
-    return pendingClientInstance;
-  }
-  if (clientInstance) {
-    if (!clientInstance.isAuthenticated()) {
-      return authenticateClient(clientInstance).then(() => clientInstance!);
+    if (pendingClientInstance) {
+        return pendingClientInstance;
+    }
+    if (clientInstance) {
+        if (!clientInstance.isAuthenticated()) {
+            return authenticateClient(clientInstance).then(() => clientInstance!);
+        }
+        return Promise.resolve(clientInstance);
     }
-    return Promise.resolve(clientInstance);
-  }
-
-  const getAddress = (!outerAddress) ?
-    getClientAddress() :
-    Promise.resolve(DEFAULT_WALLET_ADDRESS);
-
-  pendingClientInstance = getAddress
-    .then(async (addr) => {
-      const client = WalletDaemonClient.usingFetchTransport(addr.toString());
-      await authenticateClient(client);
-      outerAddress = addr;
-      clientInstance = client;
-      pendingClientInstance = null;
-      return client;
-    });
-  return pendingClientInstance;
+
+    const getAddress = (!outerAddress) ?
+        getClientAddress() :
+        Promise.resolve(DEFAULT_WALLET_ADDRESS);
+
+    pendingClientInstance = getAddress
+        .then(async (addr) => {
+            const client = WalletDaemonClient.usingFetchTransport(addr.toString());
+            await authenticateClient(client);
+            outerAddress = addr;
+            clientInstance = client;
+            pendingClientInstance = null;
+            return client;
+        });
+    return pendingClientInstance;
 }
 
 async function authenticateClient(client: WalletDaemonClient) {
-  const auth_token = await client.authRequest(["Admin"]);
-  await client.authAccept(auth_token, auth_token);
+    const auth_token = await client.authRequest(["Admin"]);
+    await client.authAccept(auth_token, auth_token);
 }
 
 
 export const authRevoke = (request: AuthRevokeTokenRequest): Promise<AuthRevokeTokenResponse> =>
-  client().then((c) => c.authRevoke(request));
+    client().then((c) => c.authRevoke(request));
 export const authGetAllJwt = (request: AuthGetAllJwtRequest): Promise<AuthGetAllJwtResponse> =>
-  client().then((c) => c.authGetAllJwt(request));
+    client().then((c) => c.authGetAllJwt(request));
 
 // settings
 export const settingsGet = (): Promise<SettingsGetResponse> =>
-  client().then((c) => c.settingsGet());
+    client().then((c) => c.settingsGet());
 export const settingsSet = (request: SettingsSetRequest): Promise<SettingsSetResponse> =>
-  client().then((c) => c.settingsSet(request));
+    client().then((c) => c.settingsSet(request));
 
 // webrtc
 export const webrtcStart = (request: WebRtcStartRequest): Promise<WebRtcStartResponse> =>
-  client().then((c) => c.webrtcStart(request));
+    client().then((c) => c.webrtcStart(request));
 
 // rpc
 export const rpcDiscover = (): Promise<string> =>
-  client().then((c) => c.rpcDiscover());
+    client().then((c) => c.rpcDiscover());
 
 // keys
 export const keysCreate = (request: KeysCreateRequest): Promise<KeysCreateResponse> =>
-  client().then((c) => c.createKey(request));
+    client().then((c) => c.createKey(request));
 export const keysList = (request: KeysListRequest): Promise<KeysListResponse> =>
-  client().then((c) => c.listKeys(request));
+    client().then((c) => c.listKeys(request));
 export const keysSetActive = (request: KeysSetActiveRequest): Promise<KeysSetActiveResponse> =>
-  client().then((c) => c.keysSetActive(request));
+    client().then((c) => c.keysSetActive(request));
 
 export const transactionsSubmit = (request: TransactionSubmitRequest): Promise<TransactionSubmitResponse> =>
-  client().then((c) => c.submitTransaction(request));
+    client().then((c) => c.submitTransaction(request));
 export const transactionsGet = (request: TransactionGetRequest): Promise<TransactionGetResponse> =>
-  client().then((c) => c.transactionsGet(request));
+    client().then((c) => c.transactionsGet(request));
 export const transactionsGetResult = (request: TransactionGetResultRequest): Promise<TransactionGetResultResponse> =>
-  client().then((c) => c.getTransactionResult(request));
+    client().then((c) => c.getTransactionResult(request));
 export const transactionsWaitResult = (request: TransactionWaitResultRequest): Promise<TransactionWaitResultResponse> =>
-  client().then((c) => c.waitForTransactionResult(request));
+    client().then((c) => c.waitForTransactionResult(request));
 export const transactionsGetAll = (request: TransactionGetAllRequest): Promise<TransactionGetAllResponse> =>
-  client().then((c) => c.transactionsList(request));
+    client().then((c) => c.transactionsList(request));
 
 // accounts
 
 export const accountsRevealFunds = (request: RevealFundsRequest): Promise<RevealFundsResponse> =>
-  client().then((c) => c.accountsRevealFunds(request));
+    client().then((c) => c.accountsRevealFunds(request));
 export const accountsClaimBurn = (request: ClaimBurnRequest): Promise<ClaimBurnResponse> =>
-  client().then((c) => c.accountsClaimBurn(request));
+    client().then((c) => c.accountsClaimBurn(request));
 export const accountsCreate = (request: AccountsCreateRequest): Promise<AccountsCreateResponse> =>
-  client().then((c) => c.accountsCreate(request));
+    client().then((c) => c.accountsCreate(request));
 export const accountsList = (request: AccountsListRequest): Promise<AccountsListResponse> =>
-  client().then((c) => c.accountsList(request));
+    client().then((c) => c.accountsList(request));
 export const accountsGetBalances = (request: AccountsGetBalancesRequest): Promise<AccountsGetBalancesResponse> =>
-  client().then((c) => c.accountsGetBalances(request));
+    client().then((c) => c.accountsGetBalances(request));
 export const accountsGet = (request: AccountGetRequest): Promise<AccountGetResponse> =>
-  client().then((c) => c.accountsGet(request));
+    client().then((c) => c.accountsGet(request));
 export const accountsTransfer = (request: AccountsTransferRequest): Promise<AccountsTransferResponse> =>
-  client().then((c) => c.accountsTransfer(request));
+    client().then((c) => c.accountsTransfer(request));
 export const accountsConfidentialTransfer = (
-  request: ConfidentialTransferRequest,
+    request: ConfidentialTransferRequest,
 ): Promise<ConfidentialTransferResponse> =>
-  client().then((c) => c.confidentialTransfer(request));
+    client().then((c) => c.confidentialTransfer(request));
 export const accountsSetDefault = (request: AccountSetDefaultRequest): Promise<AccountSetDefaultResponse> =>
-  client().then((c) => c.accountsSetDefault(request));
+    client().then((c) => c.accountsSetDefault(request));
 export const accountsCreateFreeTestCoins = (
-  request: AccountsCreateFreeTestCoinsRequest,
+    request: AccountsCreateFreeTestCoinsRequest,
 ): Promise<AccountsCreateFreeTestCoinsResponse> =>
-  client().then((c) => c.createFreeTestCoins(request));
+    client().then((c) => c.createFreeTestCoins(request));
 
 // confidential
 export const confidentialViewVaultBalance = (
-  request: ConfidentialViewVaultBalanceRequest,
+    request: ConfidentialViewVaultBalanceRequest,
 ): Promise<ConfidentialViewVaultBalanceResponse> =>
-  client().then((c) => c.viewVaultBalance(request));
+    client().then((c) => c.viewVaultBalance(request));
 
 // nfts
 export const nftList = (request: ListAccountNftRequest): Promise<ListAccountNftResponse> =>
-  client().then((c) => c.nftsList(request));
+    client().then((c) => c.nftsList(request));
 
 // validators
 
 export const validatorsClaimFees = (request: ClaimValidatorFeesRequest): Promise<ClaimValidatorFeesResponse> =>
-  client().then((c) => c.validatorsClaimFees(request));
+    client().then((c) => c.validatorsClaimFees(request));
diff --git a/applications/tari_validator_node/src/p2p/services/mempool/error.rs b/applications/tari_validator_node/src/p2p/services/mempool/error.rs
index 9d001c6b6..85b7f63e9 100644
--- a/applications/tari_validator_node/src/p2p/services/mempool/error.rs
+++ b/applications/tari_validator_node/src/p2p/services/mempool/error.rs
@@ -73,6 +73,8 @@ pub enum MempoolError {
     NoInvolvedShards { transaction_id: TransactionId },
     #[error("Invalid transaction signature")]
     InvalidSignature,
+    #[error("Transaction {transaction_id} is not signed")]
+    TransactionNotSigned { transaction_id: TransactionId },
     #[error("Network error: {0}")]
     NetworkingError(#[from] NetworkingError),
 }
diff --git a/applications/tari_validator_node/src/p2p/services/mempool/validators/before/signature.rs b/applications/tari_validator_node/src/p2p/services/mempool/validators/before/signature.rs
index 0488985e6..2a8a835c2 100644
--- a/applications/tari_validator_node/src/p2p/services/mempool/validators/before/signature.rs
+++ b/applications/tari_validator_node/src/p2p/services/mempool/validators/before/signature.rs
@@ -17,7 +17,14 @@ impl Validator<Transaction> for TransactionSignatureValidator {
     type Error = MempoolError;
 
     async fn validate(&self, transaction: &Transaction) -> Result<(), MempoolError> {
-        if !transaction.signature().verify(&transaction.into()) {
+        if transaction.signatures().is_empty() {
+            warn!(target: LOG_TARGET, "TransactionSignatureValidator - FAIL: No signatures");
+            return Err(MempoolError::TransactionNotSigned {
+                transaction_id: *transaction.id(),
+            });
+        }
+
+        if !transaction.verify_all_signatures() {
             warn!(target: LOG_TARGET, "TransactionSignatureValidator - FAIL: Invalid signature");
             return Err(MempoolError::InvalidSignature);
         }
diff --git a/applications/tari_validator_node/src/substate_resolver.rs b/applications/tari_validator_node/src/substate_resolver.rs
index c72edaadd..b1aefb3ea 100644
--- a/applications/tari_validator_node/src/substate_resolver.rs
+++ b/applications/tari_validator_node/src/substate_resolver.rs
@@ -17,7 +17,7 @@ use tari_engine_types::{
 };
 use tari_epoch_manager::{EpochManagerError, EpochManagerReader};
 use tari_indexer_lib::{error::IndexerError, substate_cache::SubstateCache, substate_scanner::SubstateScanner};
-use tari_transaction::{SubstateRequirement, Transaction};
+use tari_transaction::{SubstateRequirement, Transaction, TransactionId};
 use tari_validator_node_rpc::client::{SubstateResult, ValidatorNodeClientFactory};
 
 use crate::{
@@ -241,7 +241,7 @@ where
         transaction: &Transaction,
         current_epoch: Epoch,
     ) -> Result<VirtualSubstates, Self::Error> {
-        let claim_instructions = transaction
+        let claim_epoch_and_public_key = transaction
             .instructions()
             .iter()
             .chain(transaction.fee_instructions())
@@ -264,7 +264,7 @@ where
             VirtualSubstate::CurrentEpoch(current_epoch.as_u64()),
         );
 
-        if claim_instructions.is_empty() {
+        if claim_epoch_and_public_key.is_empty() {
             return Ok(virtual_substates);
         }
 
@@ -272,21 +272,25 @@ where
         #[allow(clippy::mutable_key_type)]
         let validators = self
             .epoch_manager
-            .get_many_validator_nodes(claim_instructions.clone())
+            .get_many_validator_nodes(claim_epoch_and_public_key.clone())
             .await?;
 
-        let signer = transaction.signer_public_key();
-        if let Some(vn) = validators.values().find(|vn| vn.fee_claim_public_key != *signer) {
+        if let Some(vn) = validators.values().find(|vn| {
+            transaction
+                .signatures()
+                .iter()
+                .all(|sig| vn.fee_claim_public_key != *sig.public_key())
+        }) {
             return Err(SubstateResolverError::UnauthorizedFeeClaim {
                 validator_address: vn.address.to_string(),
-                signer: signer.to_string(),
+                transaction_id: *transaction.id(),
             });
         }
 
         // Partition the claim instructions into local and remote claims
         let mut local_claim_vns = Vec::new();
         let mut remote_claim_vns = Vec::new();
-        claim_instructions.into_iter().for_each(|(epoch, public_key)| {
+        claim_epoch_and_public_key.into_iter().for_each(|(epoch, public_key)| {
             let vn = validators.get(&(epoch, public_key.clone())).unwrap();
             if local_committee_shard.includes_substate_address(&vn.shard_key) {
                 local_claim_vns.push((epoch, public_key))
@@ -320,8 +324,11 @@ pub enum SubstateResolverError {
     VirtualSubstateError(#[from] VirtualSubstateError),
     #[error("Epoch manager error: {0}")]
     EpochManagerError(#[from] EpochManagerError),
-    #[error("Unauthorized fee claim: validator node {validator_address} (transaction signed by: {signer})")]
-    UnauthorizedFeeClaim { validator_address: String, signer: String },
+    #[error("Unauthorized fee claim: validator node {validator_address} (transaction: {transaction_id})")]
+    UnauthorizedFeeClaim {
+        validator_address: String,
+        transaction_id: TransactionId,
+    },
     #[error("State store error: {0}")]
     StateStorageError(#[from] StateStoreError),
 }
diff --git a/applications/tari_validator_node/src/transaction_processor.rs b/applications/tari_validator_node/src/transaction_processor.rs
deleted file mode 100644
index baba09f83..000000000
--- a/applications/tari_validator_node/src/transaction_processor.rs
+++ /dev/null
@@ -1,110 +0,0 @@
-//   Copyright 2023. 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.
-
-use std::sync::Arc;
-
-use tari_common_types::types::PublicKey;
-use tari_crypto::tari_utilities::ByteArray;
-use tari_dan_app_utilities::transaction_executor::TransactionExecutor;
-use tari_dan_common_types::services::template_provider::TemplateProvider;
-use tari_dan_engine::{
-    fees::{FeeModule, FeeTable},
-    runtime::{AuthParams, ConsensusContext, RuntimeModule},
-    state_store::{memory::MemoryStateStore, StateStoreError},
-    template::LoadedTemplate,
-    transaction::{TransactionError, TransactionProcessor},
-};
-use tari_dan_storage::consensus_models::ExecutedTransaction;
-use tari_engine_types::commit_result::{ExecuteResult, FinalizeResult, RejectReason};
-use tari_template_lib::{crypto::RistrettoPublicKeyBytes, prelude::NonFungibleAddress};
-use tari_transaction::Transaction;
-
-#[derive(Debug, Clone)]
-pub struct TariDanTransactionProcessor<TTemplateProvider> {
-    template_provider: Arc<TTemplateProvider>,
-    fee_table: FeeTable,
-}
-
-impl<TTemplateProvider> TariDanTransactionProcessor<TTemplateProvider> {
-    pub fn new(template_provider: TTemplateProvider, fee_table: FeeTable) -> Self {
-        Self {
-            template_provider: Arc::new(template_provider),
-            fee_table,
-        }
-    }
-}
-
-impl<TTemplateProvider> TransactionExecutor for TariDanTransactionProcessor<TTemplateProvider>
-where TTemplateProvider: TemplateProvider<Template = LoadedTemplate>
-{
-    type Error = TransactionProcessorError;
-
-    fn execute(
-        &self,
-        transaction: Transaction,
-        state_store: MemoryStateStore,
-        consensus_context: ConsensusContext,
-    ) -> Result<ExecutedTransaction, Self::Error> {
-        // Include ownership token for the signers of this in the auth scope
-        let owner_token = get_auth_token(transaction.signer_public_key());
-        let auth_params = AuthParams {
-            initial_ownership_proofs: vec![owner_token],
-        };
-
-        let initial_cost = 0;
-        let modules: Vec<Arc<dyn RuntimeModule<TTemplateProvider>>> =
-            vec![Arc::new(FeeModule::new(initial_cost, self.fee_table.clone()))];
-
-        let processor = TransactionProcessor::new(
-            self.template_provider.clone(),
-            state_store,
-            auth_params,
-            consensus_context,
-            modules,
-        );
-        let tx_id = transaction.hash();
-        let result = match processor.execute(transaction.clone()) {
-            Ok(result) => result,
-            Err(err) => ExecuteResult {
-                finalize: FinalizeResult::reject(tx_id, RejectReason::ExecutionFailure(err.to_string())),
-                transaction_failure: None,
-                fee_receipt: None,
-            },
-        };
-
-        Ok(ExecutedTransaction::new(transaction, result))
-    }
-}
-
-fn get_auth_token(public_key: &PublicKey) -> NonFungibleAddress {
-    let public_key =
-        RistrettoPublicKeyBytes::from_bytes(public_key.as_bytes()).expect("Expected public key to be 32 bytes");
-    NonFungibleAddress::from_public_key(public_key)
-}
-
-#[derive(Debug, thiserror::Error)]
-pub enum TransactionProcessorError {
-    #[error(transparent)]
-    TransactionError(#[from] TransactionError),
-    #[error(transparent)]
-    StateStoreError(#[from] StateStoreError),
-}
diff --git a/bindings/src/types/Transaction.ts b/bindings/src/types/Transaction.ts
index b893270ed..93469996f 100644
--- a/bindings/src/types/Transaction.ts
+++ b/bindings/src/types/Transaction.ts
@@ -9,9 +9,9 @@ export interface Transaction {
   id: string;
   fee_instructions: Array<Instruction>;
   instructions: Array<Instruction>;
-  signature: TransactionSignature;
   inputs: Array<SubstateRequirement>;
-  filled_inputs: Array<VersionedSubstateId>;
   min_epoch: Epoch | null;
   max_epoch: Epoch | null;
+  signatures: Array<TransactionSignature>;
+  filled_inputs: Array<VersionedSubstateId>;
 }
diff --git a/bindings/src/types/UnsignedTransaction.ts b/bindings/src/types/UnsignedTransaction.ts
index 8fe7927ca..b98d2b095 100644
--- a/bindings/src/types/UnsignedTransaction.ts
+++ b/bindings/src/types/UnsignedTransaction.ts
@@ -2,13 +2,11 @@
 import type { Epoch } from "./Epoch";
 import type { Instruction } from "./Instruction";
 import type { SubstateRequirement } from "./SubstateRequirement";
-import type { VersionedSubstateId } from "./VersionedSubstateId";
 
 export interface UnsignedTransaction {
   fee_instructions: Array<Instruction>;
   instructions: Array<Instruction>;
   inputs: Array<SubstateRequirement>;
-  filled_inputs: Array<VersionedSubstateId>;
   min_epoch: Epoch | null;
   max_epoch: Epoch | null;
 }
diff --git a/dan_layer/engine/src/transaction/processor.rs b/dan_layer/engine/src/transaction/processor.rs
index b2ffe2826..a64616e10 100644
--- a/dan_layer/engine/src/transaction/processor.rs
+++ b/dan_layer/engine/src/transaction/processor.rs
@@ -118,10 +118,22 @@ 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())
+            .ok_or_else(|| TransactionError::InvariantError {
+                details: "Transaction must have at least one signature".to_string(),
+            })?;
+
         let runtime_interface = RuntimeInterfaceImpl::initialize(
             tracker,
             template_provider.clone(),
-            transaction.signer_public_key().clone(),
+            transaction_signer_public_key,
             entity_id_provider,
             modules,
             MAX_CALL_DEPTH,
diff --git a/dan_layer/engine/tests/account.rs b/dan_layer/engine/tests/account.rs
index b6ff54aaa..fad265693 100644
--- a/dan_layer/engine/tests/account.rs
+++ b/dan_layer/engine/tests/account.rs
@@ -6,6 +6,7 @@ use tari_dan_engine::runtime::{ActionIdent, RuntimeError};
 use tari_engine_types::instruction::Instruction;
 use tari_template_lib::{
     args,
+    constants::XTR,
     models::{Amount, ComponentAddress, ResourceAddress},
 };
 use tari_template_test_tooling::{
@@ -224,3 +225,30 @@ fn attempt_to_overwrite_account() {
     // no vaults
     assert_eq!(balances.len(), 1);
 }
+
+#[test]
+fn gasless() {
+    let mut test = TemplateTest::new::<_, &str>([]);
+    test.enable_fees();
+
+    // Create initial account with faucet funds
+    let (fee_account, fee_account_proof, fee_account_sk) = test.create_funded_account();
+    let (user_account, user_account_proof, user_account_sk) = test.create_funded_account();
+    let (user2_account, _, _) = test.create_empty_account();
+
+    let result = test.execute_expect_success(
+        Transaction::builder()
+            .fee_transaction_pay_from_component(fee_account, Amount(1000))
+            .call_method(user_account, "withdraw", args![XTR, Amount(100)])
+            .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),
+        vec![fee_account_proof, user_account_proof],
+    );
+
+    let balance = result.expect_return::<Vec<(ResourceAddress, Amount)>>(3);
+    assert_eq!(balance[0].1, 100);
+}
diff --git a/dan_layer/p2p/proto/transaction.proto b/dan_layer/p2p/proto/transaction.proto
index cc496c221..365a4f620 100644
--- a/dan_layer/p2p/proto/transaction.proto
+++ b/dan_layer/p2p/proto/transaction.proto
@@ -18,14 +18,18 @@ message CommitmentSignature {
   bytes signature_v = 3;
 }
 
-message Transaction {
+message UnsignedTransaction {
   repeated Instruction fee_instructions = 1;
   repeated Instruction instructions = 2;
-  tari.dan.common.SignatureAndPublicKey signature = 3;
-  repeated SubstateRequirement inputs = 4;
-  repeated VersionedSubstateId filled_inputs = 5;
-  tari.dan.common.Epoch min_epoch = 6;
-  tari.dan.common.Epoch max_epoch = 7;
+  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;
 }
 
 message Instruction {
diff --git a/dan_layer/p2p/src/conversions/common.rs b/dan_layer/p2p/src/conversions/common.rs
index 28a36d92f..e1e78c4fc 100644
--- a/dan_layer/p2p/src/conversions/common.rs
+++ b/dan_layer/p2p/src/conversions/common.rs
@@ -92,8 +92,8 @@ impl TryFrom<proto::common::SignatureAndPublicKey> for TransactionSignature {
     }
 }
 
-impl From<TransactionSignature> for proto::common::SignatureAndPublicKey {
-    fn from(value: TransactionSignature) -> Self {
+impl From<&TransactionSignature> for proto::common::SignatureAndPublicKey {
+    fn from(value: &TransactionSignature) -> Self {
         Self {
             public_nonce: value.signature().get_public_nonce().to_vec(),
             signature: value.signature().get_signature().to_vec(),
diff --git a/dan_layer/p2p/src/conversions/transaction.rs b/dan_layer/p2p/src/conversions/transaction.rs
index 6ef5e7e14..49c1a0058 100644
--- a/dan_layer/p2p/src/conversions/transaction.rs
+++ b/dan_layer/p2p/src/conversions/transaction.rs
@@ -44,7 +44,7 @@ use tari_template_lib::{
         ViewableBalanceProof,
     },
 };
-use tari_transaction::{SubstateRequirement, Transaction, VersionedSubstateId};
+use tari_transaction::{SubstateRequirement, Transaction, UnsignedTransaction, VersionedSubstateId};
 
 use crate::{
     proto::{
@@ -89,6 +89,49 @@ 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)
+    }
+}
+
+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,
+        }
+    }
+}
+
+//---------------------------------- 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()
@@ -99,62 +142,45 @@ impl TryFrom<proto::transaction::Transaction> for Transaction {
             .into_iter()
             .map(TryInto::try_into)
             .collect::<Result<Vec<_>, _>>()?;
-        let signature = request
-            .signature
-            .ok_or_else(|| anyhow!("invalid signature"))?
-            .try_into()?;
         let inputs = request
             .inputs
             .into_iter()
             .map(TryInto::try_into)
             .collect::<Result<_, _>>()?;
-        let filled_inputs = request
-            .filled_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));
-        let transaction = Transaction::new(
+        Ok(Self {
             fee_instructions,
             instructions,
-            signature,
             inputs,
-            filled_inputs,
             min_epoch,
             max_epoch,
-        );
-
-        Ok(transaction)
+        })
     }
 }
 
-impl From<&Transaction> for proto::transaction::Transaction {
-    fn from(transaction: &Transaction) -> Self {
-        let signature = transaction.signature().clone().into();
+impl From<&UnsignedTransaction> for proto::transaction::UnsignedTransaction {
+    fn from(transaction: &UnsignedTransaction) -> Self {
         let inputs = transaction.inputs().iter().map(Into::into).collect();
-        let filled_inputs = transaction.filled_inputs().iter().map(Into::into).collect();
-        let fee_instructions = transaction.fee_instructions().to_vec();
-        let instructions = transaction.instructions().to_vec();
         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 = fee_instructions.into_iter().map(Into::into).collect();
-        let instructions = instructions.into_iter().map(Into::into).collect();
-        proto::transaction::Transaction {
+        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,
-            signature: Some(signature),
             inputs,
-            filled_inputs,
             min_epoch,
             max_epoch,
         }
     }
 }
+
 // -------------------------------- Instruction -------------------------------- //
 
 impl TryFrom<proto::transaction::Instruction> for 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 19a324432..7e4048c9f 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
@@ -203,7 +203,7 @@ create table transactions
     transaction_id    text      not null,
     fee_instructions  text      not NULL,
     instructions      text      not NULL,
-    signature         text      not NULL,
+    signatures        text      not NULL,
     inputs            text      not NULL,
     filled_inputs     text      not NULL,
     resolved_inputs   text      NULL,
diff --git a/dan_layer/state_store_sqlite/src/reader.rs b/dan_layer/state_store_sqlite/src/reader.rs
index 4850a9263..8c2f479ee 100644
--- a/dan_layer/state_store_sqlite/src/reader.rs
+++ b/dan_layer/state_store_sqlite/src/reader.rs
@@ -564,7 +564,7 @@ impl<'tx, TAddr: NodeAddressable + Serialize + DeserializeOwned + 'tx> StateStor
             .filter(transactions::transaction_id.eq_any(tx_ids))
             .load::<sql_models::Transaction>(self.connection())
             .map_err(|e| SqliteStorageError::DieselError {
-                operation: "transactions_get_many",
+                operation: "transactions_get_any",
                 source: e,
             })?;
 
diff --git a/dan_layer/state_store_sqlite/src/schema.rs b/dan_layer/state_store_sqlite/src/schema.rs
index a6e6d6167..b894ce82c 100644
--- a/dan_layer/state_store_sqlite/src/schema.rs
+++ b/dan_layer/state_store_sqlite/src/schema.rs
@@ -313,7 +313,7 @@ diesel::table! {
         transaction_id -> Text,
         fee_instructions -> Text,
         instructions -> Text,
-        signature -> Text,
+        signatures -> Text,
         inputs -> Text,
         filled_inputs -> Text,
         resolved_inputs -> 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 aa45094a4..a34ab89b6 100644
--- a/dan_layer/state_store_sqlite/src/sql_models/transaction.rs
+++ b/dan_layer/state_store_sqlite/src/sql_models/transaction.rs
@@ -6,6 +6,7 @@ use std::{str::FromStr, time::Duration};
 use diesel::Queryable;
 use tari_dan_common_types::Epoch;
 use tari_dan_storage::{consensus_models, consensus_models::Decision, StorageError};
+use tari_transaction::UnsignedTransaction;
 use time::PrimitiveDateTime;
 
 use crate::serialization::deserialize_json;
@@ -16,7 +17,7 @@ pub struct Transaction {
     pub transaction_id: String,
     pub fee_instructions: String,
     pub instructions: String,
-    pub signature: String,
+    pub signatures: String,
     pub inputs: String,
     pub filled_inputs: String,
     pub resolved_inputs: Option<String>,
@@ -37,7 +38,7 @@ impl TryFrom<Transaction> for tari_transaction::Transaction {
     fn try_from(value: Transaction) -> Result<Self, Self::Error> {
         let fee_instructions = deserialize_json(&value.fee_instructions)?;
         let instructions = deserialize_json(&value.instructions)?;
-        let signature = deserialize_json(&value.signature)?;
+        let signatures = deserialize_json(&value.signatures)?;
 
         let inputs = deserialize_json(&value.inputs)?;
 
@@ -46,14 +47,16 @@ impl TryFrom<Transaction> for tari_transaction::Transaction {
         let max_epoch = value.max_epoch.map(|epoch| Epoch(epoch as u64));
 
         Ok(Self::new(
-            fee_instructions,
-            instructions,
-            signature,
-            inputs,
-            filled_inputs,
-            min_epoch,
-            max_epoch,
-        ))
+            UnsignedTransaction {
+                fee_instructions,
+                instructions,
+                inputs,
+                min_epoch,
+                max_epoch,
+            },
+            signatures,
+        )
+        .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 b838a7fb7..ae18fe20e 100644
--- a/dan_layer/state_store_sqlite/src/writer.rs
+++ b/dan_layer/state_store_sqlite/src/writer.rs
@@ -606,7 +606,7 @@ impl<'tx, TAddr: NodeAddressable + 'tx> StateStoreWriteTransaction for SqliteSta
             transactions::transaction_id.eq(serialize_hex(transaction.id())),
             transactions::fee_instructions.eq(serialize_json(transaction.fee_instructions())?),
             transactions::instructions.eq(serialize_json(transaction.instructions())?),
-            transactions::signature.eq(serialize_json(transaction.signature())?),
+            transactions::signatures.eq(serialize_json(transaction.signatures())?),
             transactions::inputs.eq(serialize_json(transaction.inputs())?),
             transactions::filled_inputs.eq(serialize_json(transaction.filled_inputs())?),
             transactions::resolved_inputs.eq(tx_rec.resolved_inputs().map(serialize_json).transpose()?),
@@ -710,7 +710,7 @@ impl<'tx, TAddr: NodeAddressable + 'tx> StateStoreWriteTransaction for SqliteSta
                     transactions::transaction_id.eq(serialize_hex(transaction.id())),
                     transactions::fee_instructions.eq(serialize_json(transaction.fee_instructions())?),
                     transactions::instructions.eq(serialize_json(transaction.instructions())?),
-                    transactions::signature.eq(serialize_json(transaction.signature())?),
+                    transactions::signatures.eq(serialize_json(transaction.signatures())?),
                     transactions::inputs.eq(serialize_json(transaction.inputs())?),
                     transactions::resolved_inputs.eq(rec.resolved_inputs().map(serialize_json).transpose()?),
                     transactions::filled_inputs.eq(serialize_json(transaction.filled_inputs())?),
diff --git a/dan_layer/template_lib/src/args/arg.rs b/dan_layer/template_lib/src/args/arg.rs
index 385c0d686..586d42901 100644
--- a/dan_layer/template_lib/src/args/arg.rs
+++ b/dan_layer/template_lib/src/args/arg.rs
@@ -22,12 +22,14 @@
 
 use serde::{Deserialize, Serialize};
 use tari_bor::encode;
-#[cfg(feature = "ts")]
-use ts_rs::TS;
 
 /// The possible ways to represent an instruction's argument
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-#[cfg_attr(feature = "ts", derive(TS), ts(export, export_to = "../../bindings/src/types/"))]
+#[cfg_attr(
+    feature = "ts",
+    derive(ts_rs::TS),
+    ts(export, export_to = "../../bindings/src/types/")
+)]
 pub enum Arg {
     /// The argument is in the transaction execution's workspace, which means it is the result of a previous
     /// instruction
diff --git a/dan_layer/transaction/src/builder.rs b/dan_layer/transaction/src/builder.rs
index 09bfa760f..f432ec1bf 100644
--- a/dan_layer/transaction/src/builder.rs
+++ b/dan_layer/transaction/src/builder.rs
@@ -15,21 +15,21 @@ use crate::{unsigned_transaction::UnsignedTransaction, SubstateRequirement, Tran
 #[derive(Debug, Clone, Default)]
 pub struct TransactionBuilder {
     unsigned_transaction: UnsignedTransaction,
-    signature: Option<TransactionSignature>,
+    signatures: Vec<TransactionSignature>,
 }
 
 impl TransactionBuilder {
     pub fn new() -> Self {
         Self {
             unsigned_transaction: UnsignedTransaction::default(),
-            signature: None,
+            signatures: vec![],
         }
     }
 
     pub fn with_unsigned_transaction(self, unsigned_transaction: UnsignedTransaction) -> Self {
         Self {
             unsigned_transaction,
-            signature: None,
+            signatures: vec![],
         }
     }
 
@@ -115,76 +115,66 @@ impl TransactionBuilder {
 
     pub fn with_fee_instructions(mut self, instructions: Vec<Instruction>) -> Self {
         self.unsigned_transaction.fee_instructions = instructions;
-        // Reset the signature as it is no longer valid
-        self.signature = None;
+        // Reset the signatures as they are no longer valid
+        self.signatures = vec![];
         self
     }
 
     pub fn with_fee_instructions_builder<F: FnOnce(TransactionBuilder) -> TransactionBuilder>(mut self, f: F) -> Self {
         let builder = f(TransactionBuilder::new());
         self.unsigned_transaction.fee_instructions = builder.unsigned_transaction.instructions;
-        // Reset the signature as it is no longer valid
-        self.signature = None;
+        // Reset the signatures as they are no longer valid
+        self.signatures = vec![];
         self
     }
 
     pub fn add_fee_instruction(mut self, instruction: Instruction) -> Self {
         self.unsigned_transaction.fee_instructions.push(instruction);
-        // Reset the signature as it is no longer valid
-        self.signature = None;
+        // Reset the signatures as they are no longer valid
+        self.signatures = vec![];
         self
     }
 
     pub fn add_instruction(mut self, instruction: Instruction) -> Self {
         self.unsigned_transaction.instructions.push(instruction);
-        // Reset the signature as it is no longer valid
-        self.signature = None;
+        // Reset the signatures as they are no longer valid
+        self.signatures = vec![];
         self
     }
 
     pub fn with_instructions(mut self, instructions: Vec<Instruction>) -> Self {
         self.unsigned_transaction.instructions.extend(instructions);
-        // Reset the signature as it is no longer valid
-        self.signature = None;
-        self
-    }
-
-    pub fn with_signature(mut self, signature: TransactionSignature) -> Self {
-        self.signature = Some(signature);
-        self
-    }
-
-    pub fn sign(mut self, secret_key: &PrivateKey) -> Self {
-        self.signature = Some(TransactionSignature::sign(secret_key, &self.unsigned_transaction));
+        // Reset the signatures as they are no longer valid
+        self.signatures = vec![];
         self
     }
 
     /// Add an input to use in the transaction
     pub fn add_input<I: Into<SubstateRequirement>>(mut self, input_object: I) -> Self {
         self.unsigned_transaction.inputs.insert(input_object.into());
-        // Reset the signature as it is no longer valid
-        self.signature = None;
+        // Reset the signatures as they are no longer valid
+        self.signatures = vec![];
         self
     }
 
     pub fn with_inputs<I: IntoIterator<Item = SubstateRequirement>>(mut self, inputs: I) -> Self {
         self.unsigned_transaction.inputs.extend(inputs);
-        // Reset the signature as it is no longer valid
-        self.signature = None;
+        // Reset the signatures as they are no longer valid
+        self.signatures = vec![];
         self
     }
 
     pub fn with_min_epoch(mut self, min_epoch: Option<Epoch>) -> Self {
         self.unsigned_transaction.min_epoch = min_epoch;
-        // Reset the signature as it is no longer valid
-        self.signature = None;
+        // Reset the signatures as they are no longer valid
+        self.signatures = vec![];
         self
     }
 
     pub fn with_max_epoch(mut self, max_epoch: Option<Epoch>) -> Self {
         self.unsigned_transaction.max_epoch = max_epoch;
-        // Reset the signature as it is no longer valid
-        self.signature = None;
+        // Reset the signatures as they are no longer valid
+        self.signatures = vec![];
         self
     }
 
@@ -192,24 +182,13 @@ impl TransactionBuilder {
         self.unsigned_transaction
     }
 
+    pub fn sign(mut self, secret_key: &PrivateKey) -> Self {
+        self.signatures
+            .push(TransactionSignature::sign(secret_key, &self.unsigned_transaction));
+        self
+    }
+
     pub fn build(self) -> Transaction {
-        let UnsignedTransaction {
-            fee_instructions,
-            instructions,
-            inputs,
-            filled_inputs,
-            min_epoch,
-            max_epoch,
-        } = self.unsigned_transaction;
-
-        Transaction::new(
-            fee_instructions,
-            instructions,
-            self.signature.expect("not signed"),
-            inputs,
-            filled_inputs,
-            min_epoch,
-            max_epoch,
-        )
+        Transaction::new(self.unsigned_transaction, self.signatures)
     }
 }
diff --git a/dan_layer/transaction/src/lib.rs b/dan_layer/transaction/src/lib.rs
index 69b577137..4fb8d7025 100644
--- a/dan_layer/transaction/src/lib.rs
+++ b/dan_layer/transaction/src/lib.rs
@@ -22,12 +22,14 @@
 
 mod builder;
 mod signature;
+mod substate;
 mod transaction;
 mod transaction_id;
 mod unsigned_transaction;
 
 pub use builder::TransactionBuilder;
 pub use signature::TransactionSignature;
+pub use substate::*;
 pub use tari_engine_types::instruction::Instruction;
 pub use transaction::*;
 pub use transaction_id::*;
diff --git a/dan_layer/transaction/src/substate.rs b/dan_layer/transaction/src/substate.rs
new file mode 100644
index 000000000..8d674831b
--- /dev/null
+++ b/dan_layer/transaction/src/substate.rs
@@ -0,0 +1,260 @@
+//    Copyright 2024 The Tari Project
+//    SPDX-License-Identifier: BSD-3-Clause
+
+use std::{borrow::Borrow, fmt::Display, str::FromStr};
+
+use serde::{Deserialize, Serialize};
+use tari_dan_common_types::{shard::Shard, SubstateAddress};
+use tari_engine_types::{serde_with, substate::SubstateId};
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+#[cfg_attr(
+    feature = "ts",
+    derive(ts_rs::TS),
+    ts(export, export_to = "../../bindings/src/types/")
+)]
+pub struct SubstateRequirement {
+    #[serde(with = "serde_with::string")]
+    pub substate_id: SubstateId,
+    pub version: Option<u32>,
+}
+
+impl SubstateRequirement {
+    pub fn new(address: SubstateId, version: Option<u32>) -> Self {
+        Self {
+            substate_id: address,
+            version,
+        }
+    }
+
+    pub fn with_version(address: SubstateId, version: u32) -> Self {
+        Self {
+            substate_id: address,
+            version: Some(version),
+        }
+    }
+
+    pub fn substate_id(&self) -> &SubstateId {
+        &self.substate_id
+    }
+
+    pub fn into_substate_id(self) -> SubstateId {
+        self.substate_id
+    }
+
+    pub fn version(&self) -> Option<u32> {
+        self.version
+    }
+
+    pub fn to_substate_address(&self) -> Option<SubstateAddress> {
+        Some(SubstateAddress::from_substate_id(self.substate_id(), self.version()?))
+    }
+
+    /// Calculates and returns the shard number that this SubstateAddress belongs.
+    /// A shard is a division of the 256-bit shard space.
+    /// If the substate version is not known, None is returned.
+    pub fn to_committee_shard(&self, num_committees: u32) -> Option<Shard> {
+        Some(self.to_substate_address()?.to_shard(num_committees))
+    }
+
+    pub fn to_versioned(&self) -> Option<VersionedSubstateId> {
+        self.version.map(|v| VersionedSubstateId {
+            substate_id: self.substate_id.clone(),
+            version: v,
+        })
+    }
+
+    pub fn or_zero_version(self) -> VersionedSubstateId {
+        VersionedSubstateId {
+            version: self.version.unwrap_or(0),
+            substate_id: self.substate_id,
+        }
+    }
+}
+
+impl FromStr for SubstateRequirement {
+    type Err = SubstateRequirementParseError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let mut parts = s.split(':');
+
+        // parse the substate id
+        let address = parts
+            .next()
+            .ok_or_else(|| SubstateRequirementParseError(s.to_string()))?;
+        let address = SubstateId::from_str(address).map_err(|_| SubstateRequirementParseError(s.to_string()))?;
+
+        // parse the version (optional)
+        let version = match parts.next() {
+            Some(v) => {
+                let parse_version = v.parse().map_err(|_| SubstateRequirementParseError(s.to_string()))?;
+                Some(parse_version)
+            },
+            None => None,
+        };
+
+        Ok(Self {
+            substate_id: address,
+            version,
+        })
+    }
+}
+
+impl Display for SubstateRequirement {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self.version {
+            Some(v) => write!(f, "{}:{}", self.substate_id, v),
+            None => write!(f, "{}", self.substate_id),
+        }
+    }
+}
+
+impl From<VersionedSubstateId> for SubstateRequirement {
+    fn from(value: VersionedSubstateId) -> Self {
+        Self::with_version(value.substate_id, value.version)
+    }
+}
+
+impl<T: Into<SubstateId>> From<T> for SubstateRequirement {
+    fn from(value: T) -> Self {
+        Self::new(value.into(), None)
+    }
+}
+
+impl PartialEq for SubstateRequirement {
+    fn eq(&self, other: &Self) -> bool {
+        self.substate_id == other.substate_id
+    }
+}
+
+impl Eq for SubstateRequirement {}
+
+// Only consider the substate id in maps. This means that duplicates found if the substate id is the same regardless of
+// the version.
+impl std::hash::Hash for SubstateRequirement {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.substate_id.hash(state);
+    }
+}
+
+#[derive(Debug, thiserror::Error)]
+#[error("Failed to parse substate requirement {0}")]
+pub struct SubstateRequirementParseError(String);
+
+#[derive(Debug, Clone, Hash, PartialEq, Eq, Deserialize, Serialize)]
+#[cfg_attr(
+    feature = "ts",
+    derive(ts_rs::TS),
+    ts(export, export_to = "../../bindings/src/types/")
+)]
+pub struct VersionedSubstateId {
+    #[serde(with = "serde_with::string")]
+    pub substate_id: SubstateId,
+    pub version: u32,
+}
+
+impl VersionedSubstateId {
+    pub fn new(substate_id: SubstateId, version: u32) -> Self {
+        Self { substate_id, version }
+    }
+
+    pub fn substate_id(&self) -> &SubstateId {
+        &self.substate_id
+    }
+
+    pub fn version(&self) -> u32 {
+        self.version
+    }
+
+    pub fn to_substate_address(&self) -> SubstateAddress {
+        SubstateAddress::from_substate_id(self.substate_id(), self.version())
+    }
+
+    /// Calculates and returns the shard number that this SubstateAddress belongs.
+    /// A shard is an equal division of the 256-bit shard space.
+    pub fn to_committee_shard(&self, num_committees: u32) -> Shard {
+        self.to_substate_address().to_shard(num_committees)
+    }
+
+    pub fn to_previous_version(&self) -> Option<Self> {
+        self.version
+            .checked_sub(1)
+            .map(|v| Self::new(self.substate_id.clone(), v))
+    }
+
+    pub fn to_next_version(&self) -> Self {
+        Self::new(self.substate_id.clone(), self.version + 1)
+    }
+}
+
+impl FromStr for VersionedSubstateId {
+    type Err = SubstateRequirementParseError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let mut parts = s.split(':');
+
+        // parse the substate id
+        let address = parts
+            .next()
+            .ok_or_else(|| SubstateRequirementParseError(s.to_string()))?;
+        let address = SubstateId::from_str(address).map_err(|_| SubstateRequirementParseError(s.to_string()))?;
+
+        // parse the version
+        let version = parts
+            .next()
+            .ok_or_else(|| SubstateRequirementParseError(s.to_string()))
+            .and_then(|v| v.parse().map_err(|_| SubstateRequirementParseError(s.to_string())))?;
+
+        Ok(Self {
+            substate_id: address,
+            version,
+        })
+    }
+}
+
+impl Display for VersionedSubstateId {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}:{}", self.substate_id, self.version)
+    }
+}
+
+impl TryFrom<SubstateRequirement> for VersionedSubstateId {
+    type Error = VersionedSubstateIdError;
+
+    fn try_from(value: SubstateRequirement) -> Result<Self, Self::Error> {
+        match value.version {
+            Some(v) => Ok(Self::new(value.substate_id, v)),
+            None => Err(VersionedSubstateIdError::SubstateRequirementNotVersioned(
+                value.substate_id,
+            )),
+        }
+    }
+}
+
+impl Borrow<SubstateId> for VersionedSubstateId {
+    fn borrow(&self) -> &SubstateId {
+        &self.substate_id
+    }
+}
+
+#[derive(Debug, thiserror::Error)]
+pub enum VersionedSubstateIdError {
+    #[error("Substate requirement {0} is not versioned")]
+    SubstateRequirementNotVersioned(SubstateId),
+}
+
+#[cfg(test)]
+mod tests {
+    use indexmap::IndexSet;
+    use tari_template_lib::models::{ComponentAddress, ObjectKey};
+
+    use super::*;
+
+    #[test]
+    fn it_hashes_identically_to_a_substate_id() {
+        let substate_id = SubstateId::Component(ComponentAddress::new(ObjectKey::default()));
+        let mut set = IndexSet::new();
+        set.extend([VersionedSubstateId::new(substate_id.clone(), 0)]);
+        assert!(set.contains(&substate_id));
+    }
+}
diff --git a/dan_layer/transaction/src/transaction.rs b/dan_layer/transaction/src/transaction.rs
index 56b6bd85f..615aa9ece 100644
--- a/dan_layer/transaction/src/transaction.rs
+++ b/dan_layer/transaction/src/transaction.rs
@@ -1,22 +1,29 @@
 //   Copyright 2023 The Tari Project
 //   SPDX-License-Identifier: BSD-3-Clause
 
-use std::{borrow::Borrow, collections::HashSet, fmt::Display, str::FromStr};
+use std::collections::HashSet;
 
 use indexmap::IndexSet;
 use serde::{Deserialize, Serialize};
 use tari_common_types::types::PublicKey;
-use tari_dan_common_types::{shard::Shard, Epoch, SubstateAddress};
+use tari_crypto::ristretto::RistrettoSecretKey;
+use tari_dan_common_types::{Epoch, SubstateAddress};
 use tari_engine_types::{
     hashing::{hasher32, EngineHashDomainLabel},
     indexed_value::{IndexedValue, IndexedValueError},
     instruction::Instruction,
-    serde_with,
     substate::SubstateId,
 };
 use tari_template_lib::{models::ComponentAddress, Hash};
 
-use crate::{builder::TransactionBuilder, transaction_id::TransactionId, TransactionSignature};
+use crate::{
+    builder::TransactionBuilder,
+    transaction_id::TransactionId,
+    SubstateRequirement,
+    TransactionSignature,
+    UnsignedTransaction,
+    VersionedSubstateId,
+};
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
 #[cfg_attr(
@@ -27,16 +34,11 @@ use crate::{builder::TransactionBuilder, transaction_id::TransactionId, Transact
 pub struct Transaction {
     #[cfg_attr(feature = "ts", ts(type = "string"))]
     id: TransactionId,
-    fee_instructions: Vec<Instruction>,
-    instructions: Vec<Instruction>,
-    signature: TransactionSignature,
-
-    /// Input objects that may be downed (write) or referenced (read) by this transaction.
-    inputs: IndexSet<SubstateRequirement>,
+    #[serde(flatten)]
+    transaction: UnsignedTransaction,
+    signatures: Vec<TransactionSignature>,
     /// Inputs filled by some authority. These are not part of the transaction hash nor the signature
     filled_inputs: IndexSet<VersionedSubstateId>,
-    min_epoch: Option<Epoch>,
-    max_epoch: Option<Epoch>,
 }
 
 impl Transaction {
@@ -44,37 +46,32 @@ impl Transaction {
         TransactionBuilder::new()
     }
 
-    pub fn new(
-        fee_instructions: Vec<Instruction>,
-        instructions: Vec<Instruction>,
-        signature: TransactionSignature,
-        inputs: IndexSet<SubstateRequirement>,
-        filled_inputs: IndexSet<VersionedSubstateId>,
-        min_epoch: Option<Epoch>,
-        max_epoch: Option<Epoch>,
-    ) -> Self {
+    pub fn new(unsigned_transaction: UnsignedTransaction, signatures: Vec<TransactionSignature>) -> Self {
         let mut tx = Self {
             id: TransactionId::default(),
-            fee_instructions,
-            instructions,
-            signature,
-            inputs,
-            filled_inputs,
-            min_epoch,
-            max_epoch,
+            transaction: unsigned_transaction,
+            filled_inputs: IndexSet::new(),
+            signatures,
         };
         tx.id = tx.calculate_hash();
         tx
     }
 
+    pub fn sign(mut self, secret: &RistrettoSecretKey) -> Self {
+        let sig = TransactionSignature::sign(secret, &self.transaction);
+        self.signatures.push(sig);
+        self.id = self.calculate_hash();
+        self
+    }
+
+    pub fn with_filled_inputs(self, filled_inputs: IndexSet<VersionedSubstateId>) -> Self {
+        Self { filled_inputs, ..self }
+    }
+
     fn calculate_hash(&self) -> TransactionId {
         hasher32(EngineHashDomainLabel::Transaction)
-            .chain(&self.signature)
-            .chain(&self.fee_instructions)
-            .chain(&self.instructions)
-            .chain(&self.inputs)
-            .chain(&self.min_epoch)
-            .chain(&self.max_epoch)
+            .chain(&self.signatures)
+            .chain(&self.transaction)
             .result()
             .into_array()
             .into()
@@ -89,24 +86,32 @@ impl Transaction {
         id == self.id
     }
 
+    pub fn unsigned_transaction(&self) -> &UnsignedTransaction {
+        &self.transaction
+    }
+
     pub fn hash(&self) -> Hash {
         self.id.into_array().into()
     }
 
     pub fn fee_instructions(&self) -> &[Instruction] {
-        &self.fee_instructions
+        &self.transaction.fee_instructions
     }
 
     pub fn instructions(&self) -> &[Instruction] {
-        &self.instructions
+        &self.transaction.instructions
     }
 
-    pub fn signature(&self) -> &TransactionSignature {
-        &self.signature
+    pub fn signatures(&self) -> &[TransactionSignature] {
+        &self.signatures
     }
 
-    pub fn signer_public_key(&self) -> &PublicKey {
-        self.signature.public_key()
+    pub fn verify_all_signatures(&self) -> bool {
+        if self.signatures.is_empty() {
+            return false;
+        }
+
+        self.signatures().iter().all(|sig| sig.verify(&self.transaction))
     }
 
     pub fn involved_shards_iter(&self) -> impl Iterator<Item = SubstateAddress> + '_ {
@@ -114,18 +119,19 @@ impl Transaction {
     }
 
     pub fn inputs(&self) -> &IndexSet<SubstateRequirement> {
-        &self.inputs
+        &self.transaction.inputs
     }
 
     fn input_addresses_iter(&self) -> impl Iterator<Item = SubstateAddress> + '_ {
-        self.inputs
+        self.transaction
+            .inputs
             .iter()
             .filter_map(|i: &SubstateRequirement| i.to_substate_address())
     }
 
     /// Returns (fee instructions, instructions)
     pub fn into_instructions(self) -> (Vec<Instruction>, Vec<Instruction>) {
-        (self.fee_instructions, self.instructions)
+        (self.transaction.fee_instructions, self.transaction.instructions)
     }
 
     pub fn all_inputs_iter(&self) -> impl Iterator<Item = SubstateRequirement> + '_ {
@@ -184,11 +190,11 @@ impl Transaction {
     }
 
     pub fn min_epoch(&self) -> Option<Epoch> {
-        self.min_epoch
+        self.transaction.min_epoch
     }
 
     pub fn max_epoch(&self) -> Option<Epoch> {
-        self.max_epoch
+        self.transaction.max_epoch
     }
 
     pub fn as_referenced_components(&self) -> impl Iterator<Item = &ComponentAddress> + '_ {
@@ -241,254 +247,3 @@ impl Transaction {
         self.inputs().iter().any(|i| i.version().is_none())
     }
 }
-
-#[derive(Debug, Clone, Deserialize, Serialize)]
-#[cfg_attr(
-    feature = "ts",
-    derive(ts_rs::TS),
-    ts(export, export_to = "../../bindings/src/types/")
-)]
-pub struct SubstateRequirement {
-    #[serde(with = "serde_with::string")]
-    pub substate_id: SubstateId,
-    pub version: Option<u32>,
-}
-
-impl SubstateRequirement {
-    pub fn new(address: SubstateId, version: Option<u32>) -> Self {
-        Self {
-            substate_id: address,
-            version,
-        }
-    }
-
-    pub fn with_version(address: SubstateId, version: u32) -> Self {
-        Self {
-            substate_id: address,
-            version: Some(version),
-        }
-    }
-
-    pub fn substate_id(&self) -> &SubstateId {
-        &self.substate_id
-    }
-
-    pub fn into_substate_id(self) -> SubstateId {
-        self.substate_id
-    }
-
-    pub fn version(&self) -> Option<u32> {
-        self.version
-    }
-
-    pub fn to_substate_address(&self) -> Option<SubstateAddress> {
-        Some(SubstateAddress::from_substate_id(self.substate_id(), self.version()?))
-    }
-
-    /// Calculates and returns the shard number that this SubstateAddress belongs.
-    /// A shard is a division of the 256-bit shard space.
-    /// If the substate version is not known, None is returned.
-    pub fn to_committee_shard(&self, num_committees: u32) -> Option<Shard> {
-        Some(self.to_substate_address()?.to_shard(num_committees))
-    }
-
-    pub fn to_versioned(&self) -> Option<VersionedSubstateId> {
-        self.version.map(|v| VersionedSubstateId {
-            substate_id: self.substate_id.clone(),
-            version: v,
-        })
-    }
-
-    pub fn or_zero_version(self) -> VersionedSubstateId {
-        VersionedSubstateId {
-            version: self.version.unwrap_or(0),
-            substate_id: self.substate_id,
-        }
-    }
-}
-
-impl FromStr for SubstateRequirement {
-    type Err = SubstateRequirementParseError;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        let mut parts = s.split(':');
-
-        // parse the substate id
-        let address = parts
-            .next()
-            .ok_or_else(|| SubstateRequirementParseError(s.to_string()))?;
-        let address = SubstateId::from_str(address).map_err(|_| SubstateRequirementParseError(s.to_string()))?;
-
-        // parse the version (optional)
-        let version = match parts.next() {
-            Some(v) => {
-                let parse_version = v.parse().map_err(|_| SubstateRequirementParseError(s.to_string()))?;
-                Some(parse_version)
-            },
-            None => None,
-        };
-
-        Ok(Self {
-            substate_id: address,
-            version,
-        })
-    }
-}
-
-impl Display for SubstateRequirement {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self.version {
-            Some(v) => write!(f, "{}:{}", self.substate_id, v),
-            None => write!(f, "{}", self.substate_id),
-        }
-    }
-}
-
-impl From<VersionedSubstateId> for SubstateRequirement {
-    fn from(value: VersionedSubstateId) -> Self {
-        Self::with_version(value.substate_id, value.version)
-    }
-}
-
-impl<T: Into<SubstateId>> From<T> for SubstateRequirement {
-    fn from(value: T) -> Self {
-        Self::new(value.into(), None)
-    }
-}
-
-impl PartialEq for SubstateRequirement {
-    fn eq(&self, other: &Self) -> bool {
-        self.substate_id == other.substate_id
-    }
-}
-
-impl Eq for SubstateRequirement {}
-
-// Only consider the substate id in maps. This means that duplicates found if the substate id is the same regardless of
-// the version.
-impl std::hash::Hash for SubstateRequirement {
-    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
-        self.substate_id.hash(state);
-    }
-}
-
-#[derive(Debug, thiserror::Error)]
-#[error("Failed to parse substate requirement {0}")]
-pub struct SubstateRequirementParseError(String);
-
-#[derive(Debug, Clone, Hash, PartialEq, Eq, Deserialize, Serialize)]
-#[cfg_attr(
-    feature = "ts",
-    derive(ts_rs::TS),
-    ts(export, export_to = "../../bindings/src/types/")
-)]
-pub struct VersionedSubstateId {
-    #[serde(with = "serde_with::string")]
-    pub substate_id: SubstateId,
-    pub version: u32,
-}
-
-impl VersionedSubstateId {
-    pub fn new(substate_id: SubstateId, version: u32) -> Self {
-        Self { substate_id, version }
-    }
-
-    pub fn substate_id(&self) -> &SubstateId {
-        &self.substate_id
-    }
-
-    pub fn version(&self) -> u32 {
-        self.version
-    }
-
-    pub fn to_substate_address(&self) -> SubstateAddress {
-        SubstateAddress::from_substate_id(self.substate_id(), self.version())
-    }
-
-    /// Calculates and returns the shard number that this SubstateAddress belongs.
-    /// A shard is an equal division of the 256-bit shard space.
-    pub fn to_committee_shard(&self, num_committees: u32) -> Shard {
-        self.to_substate_address().to_shard(num_committees)
-    }
-
-    pub fn to_previous_version(&self) -> Option<Self> {
-        self.version
-            .checked_sub(1)
-            .map(|v| Self::new(self.substate_id.clone(), v))
-    }
-
-    pub fn to_next_version(&self) -> Self {
-        Self::new(self.substate_id.clone(), self.version + 1)
-    }
-}
-
-impl FromStr for VersionedSubstateId {
-    type Err = SubstateRequirementParseError;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        let mut parts = s.split(':');
-
-        // parse the substate id
-        let address = parts
-            .next()
-            .ok_or_else(|| SubstateRequirementParseError(s.to_string()))?;
-        let address = SubstateId::from_str(address).map_err(|_| SubstateRequirementParseError(s.to_string()))?;
-
-        // parse the version
-        let version = parts
-            .next()
-            .ok_or_else(|| SubstateRequirementParseError(s.to_string()))
-            .and_then(|v| v.parse().map_err(|_| SubstateRequirementParseError(s.to_string())))?;
-
-        Ok(Self {
-            substate_id: address,
-            version,
-        })
-    }
-}
-
-impl Display for VersionedSubstateId {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{}:{}", self.substate_id, self.version)
-    }
-}
-
-impl TryFrom<SubstateRequirement> for VersionedSubstateId {
-    type Error = VersionedSubstateIdError;
-
-    fn try_from(value: SubstateRequirement) -> Result<Self, Self::Error> {
-        match value.version {
-            Some(v) => Ok(Self::new(value.substate_id, v)),
-            None => Err(VersionedSubstateIdError::SubstateRequirementNotVersioned(
-                value.substate_id,
-            )),
-        }
-    }
-}
-
-impl Borrow<SubstateId> for VersionedSubstateId {
-    fn borrow(&self) -> &SubstateId {
-        &self.substate_id
-    }
-}
-
-#[derive(Debug, thiserror::Error)]
-pub enum VersionedSubstateIdError {
-    #[error("Substate requirement {0} is not versioned")]
-    SubstateRequirementNotVersioned(SubstateId),
-}
-
-#[cfg(test)]
-mod tests {
-    use tari_template_lib::models::ObjectKey;
-
-    use super::*;
-
-    #[test]
-    fn it_hashes_identically_to_a_substate_id() {
-        let substate_id = SubstateId::Component(ComponentAddress::new(ObjectKey::default()));
-        let mut set = IndexSet::new();
-        set.extend([VersionedSubstateId::new(substate_id.clone(), 0)]);
-        assert!(set.contains(&substate_id));
-    }
-}
diff --git a/dan_layer/transaction/src/unsigned_transaction.rs b/dan_layer/transaction/src/unsigned_transaction.rs
index 4fbf0c552..ae55fe113 100644
--- a/dan_layer/transaction/src/unsigned_transaction.rs
+++ b/dan_layer/transaction/src/unsigned_transaction.rs
@@ -1,14 +1,22 @@
-//   Copyright 2024 The Tari Project
+//   Copyright 2023 The Tari Project
 //   SPDX-License-Identifier: BSD-3-Clause
 
+use std::collections::HashSet;
+
 use indexmap::IndexSet;
 use serde::{Deserialize, Serialize};
+use tari_crypto::ristretto::RistrettoSecretKey;
 use tari_dan_common_types::Epoch;
-use tari_engine_types::instruction::Instruction;
+use tari_engine_types::{
+    indexed_value::{IndexedValue, IndexedValueError},
+    instruction::Instruction,
+    substate::SubstateId,
+};
+use tari_template_lib::models::ComponentAddress;
 
-use crate::{SubstateRequirement, Transaction, VersionedSubstateId};
+use crate::{builder::TransactionBuilder, SubstateRequirement, Transaction, TransactionSignature};
 
-#[derive(Debug, Clone, Default, Serialize, Deserialize)]
+#[derive(Debug, Clone, Serialize, Deserialize, Default)]
 #[cfg_attr(
     feature = "ts",
     derive(ts_rs::TS),
@@ -17,23 +25,111 @@ use crate::{SubstateRequirement, Transaction, VersionedSubstateId};
 pub struct UnsignedTransaction {
     pub fee_instructions: Vec<Instruction>,
     pub instructions: Vec<Instruction>,
-    /// Input objects that may be downed by this transaction
+
+    /// Input objects that may be downed (write) or referenced (read) by this transaction.
     pub inputs: IndexSet<SubstateRequirement>,
-    /// Inputs filled by some authority. These are not part of the transaction hash nor the signature
-    pub filled_inputs: IndexSet<VersionedSubstateId>,
     pub min_epoch: Option<Epoch>,
     pub max_epoch: Option<Epoch>,
 }
 
-impl From<&Transaction> for UnsignedTransaction {
-    fn from(tx: &Transaction) -> Self {
+impl UnsignedTransaction {
+    pub fn builder() -> TransactionBuilder {
+        TransactionBuilder::new()
+    }
+
+    pub fn new(
+        fee_instructions: Vec<Instruction>,
+        instructions: Vec<Instruction>,
+        inputs: IndexSet<SubstateRequirement>,
+        min_epoch: Option<Epoch>,
+        max_epoch: Option<Epoch>,
+    ) -> Self {
         Self {
-            fee_instructions: tx.fee_instructions().to_vec(),
-            instructions: tx.instructions().to_vec(),
-            inputs: tx.inputs().clone(),
-            filled_inputs: tx.filled_inputs().clone(),
-            min_epoch: tx.min_epoch(),
-            max_epoch: tx.max_epoch(),
+            fee_instructions,
+            instructions,
+            inputs,
+            min_epoch,
+            max_epoch,
+        }
+    }
+
+    pub fn fee_instructions(&self) -> &[Instruction] {
+        &self.fee_instructions
+    }
+
+    pub fn instructions(&self) -> &[Instruction] {
+        &self.instructions
+    }
+
+    pub fn inputs(&self) -> &IndexSet<SubstateRequirement> {
+        &self.inputs
+    }
+
+    /// Returns (fee instructions, instructions)
+    pub fn into_instructions(self) -> (Vec<Instruction>, Vec<Instruction>) {
+        (self.fee_instructions, self.instructions)
+    }
+
+    pub fn min_epoch(&self) -> Option<Epoch> {
+        self.min_epoch
+    }
+
+    pub fn max_epoch(&self) -> Option<Epoch> {
+        self.max_epoch
+    }
+
+    pub fn as_referenced_components(&self) -> impl Iterator<Item = &ComponentAddress> + '_ {
+        self.instructions()
+            .iter()
+            .chain(self.fee_instructions())
+            .filter_map(|instruction| {
+                if let Instruction::CallMethod { component_address, .. } = instruction {
+                    Some(component_address)
+                } else {
+                    None
+                }
+            })
+    }
+
+    /// Returns all substates addresses referenced by this transaction
+    pub fn to_referenced_substates(&self) -> Result<HashSet<SubstateId>, IndexedValueError> {
+        let all_instructions = self.instructions().iter().chain(self.fee_instructions());
+
+        let mut substates = HashSet::new();
+        for instruction in all_instructions {
+            match instruction {
+                Instruction::CallFunction { args, .. } => {
+                    for arg in args.iter().filter_map(|a| a.as_literal_bytes()) {
+                        let value = IndexedValue::from_raw(arg)?;
+                        substates.extend(value.referenced_substates().filter(|id| !id.is_virtual()));
+                    }
+                },
+                Instruction::CallMethod {
+                    component_address,
+                    args,
+                    ..
+                } => {
+                    substates.insert(SubstateId::Component(*component_address));
+                    for arg in args.iter().filter_map(|a| a.as_literal_bytes()) {
+                        let value = IndexedValue::from_raw(arg)?;
+                        substates.extend(value.referenced_substates().filter(|id| !id.is_virtual()));
+                    }
+                },
+                Instruction::ClaimBurn { claim } => {
+                    substates.insert(SubstateId::UnclaimedConfidentialOutput(claim.output_address));
+                },
+                _ => {},
+            }
         }
+        Ok(substates)
+    }
+
+    pub fn has_inputs_without_version(&self) -> bool {
+        self.inputs().iter().any(|i| i.version().is_none())
+    }
+
+    pub fn sign(self, secret: &RistrettoSecretKey) -> Transaction {
+        let signature = TransactionSignature::sign(secret, &self);
+        Transaction::new(self, vec![signature])
     }
 }
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 00573df08..e5172360d 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,22 +30,21 @@ 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,
-    signature         TEXT     NOT NULL,
-    sender_public_key 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,
+    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
 );
 
 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 05a33a956..55c256d53 100644
--- a/dan_layer/wallet/storage_sqlite/src/models/transaction.rs
+++ b/dan_layer/wallet/storage_sqlite/src/models/transaction.rs
@@ -9,8 +9,7 @@ use tari_dan_wallet_sdk::{
     models::{TransactionStatus, WalletTransaction},
     storage::WalletStorageError,
 };
-use tari_transaction::TransactionSignature;
-use tari_utilities::hex::Hex;
+use tari_transaction::UnsignedTransaction;
 
 use crate::{schema::transactions, serialization::deserialize_json};
 
@@ -20,8 +19,7 @@ pub struct Transaction {
     pub id: i32,
     pub hash: String,
     pub instructions: String,
-    pub signature: String,
-    pub sender_public_key: String,
+    pub signatures: String,
     pub fee_instructions: String,
     pub inputs: String,
     pub result: Option<String>,
@@ -41,26 +39,19 @@ pub struct Transaction {
 
 impl Transaction {
     pub fn try_into_wallet_transaction(self) -> Result<WalletTransaction, WalletStorageError> {
-        let signature = deserialize_json(&self.signature)?;
-        let sender_public_key =
-            Hex::from_hex(&self.sender_public_key).map_err(|e| WalletStorageError::DecodingError {
-                operation: "transaction_get",
-                item: "sender_address",
-                details: e.to_string(),
-            })?;
-        let signature = TransactionSignature::new(sender_public_key, signature);
+        let signatures = deserialize_json(&self.signatures)?;
         let inputs = deserialize_json(&self.inputs)?;
 
         Ok(WalletTransaction {
             transaction: tari_transaction::Transaction::new(
-                deserialize_json(&self.fee_instructions)?,
-                deserialize_json(&self.instructions)?,
-                signature,
-                inputs,
-                // empty - We do not know filled inputs
-                Default::default(),
-                self.min_epoch.map(|epoch| Epoch(epoch as u64)),
-                self.max_epoch.map(|epoch| Epoch(epoch as u64)),
+                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,
             ),
             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 520a917eb..a72aee550 100644
--- a/dan_layer/wallet/storage_sqlite/src/schema.rs
+++ b/dan_layer/wallet/storage_sqlite/src/schema.rs
@@ -105,8 +105,7 @@ diesel::table! {
         id -> Integer,
         hash -> Text,
         instructions -> Text,
-        signature -> Text,
-        sender_public_key -> Text,
+        signatures -> Text,
         fee_instructions -> Text,
         inputs -> Text,
         result -> Nullable<Text>,
diff --git a/dan_layer/wallet/storage_sqlite/src/writer.rs b/dan_layer/wallet/storage_sqlite/src/writer.rs
index e3990bea1..7e0e8b66d 100644
--- a/dan_layer/wallet/storage_sqlite/src/writer.rs
+++ b/dan_layer/wallet/storage_sqlite/src/writer.rs
@@ -276,8 +276,7 @@ impl WalletStoreWriter for WriteTransaction<'_> {
                 transactions::hash.eq(transaction.id().to_string()),
                 transactions::fee_instructions.eq(serialize_json(transaction.fee_instructions())?),
                 transactions::instructions.eq(serialize_json(transaction.instructions())?),
-                transactions::sender_public_key.eq(transaction.signer_public_key().to_hex()),
-                transactions::signature.eq(serialize_json(transaction.signature().signature())?),
+                transactions::signatures.eq(serialize_json(transaction.signatures())?),
                 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/integration_tests/tests/features/wallet_daemon.feature b/integration_tests/tests/features/wallet_daemon.feature
index d892f5997..f6bb4919b 100644
--- a/integration_tests/tests/features/wallet_daemon.feature
+++ b/integration_tests/tests/features/wallet_daemon.feature
@@ -133,30 +133,16 @@ Feature: Wallet Daemon
   @serial
   Scenario: Create and mint account NFT
     Given fees are disabled
-        # Initialize a base node, wallet, miner and VN
-    Given a base node BASE
-    Given a wallet WALLET connected to base node BASE
-    Given a miner MINER connected to base node BASE and wallet WALLET
-
-        # Initialize a VN
-    Given a validator node VAL_1 connected to base node BASE and wallet daemon WALLET_D
-
-        # The wallet must have some funds before the VN sends transactions
-    When miner MINER mines 6 new blocks
-    When wallet WALLET has at least 20000000 uT
+    # Initialize a base node, wallet, miner and VN
+    Given a network with registered validator VAL_1 and wallet daemon WALLET_D
 
-        # VN registration
-    When validator node VAL_1 sends a registration transaction to base wallet WALLET
-    When miner MINER mines 16 new blocks
-    Then the validator node VAL_1 is listed as registered
+    # Initialize an indexer
+    Given an indexer IDX connected to base node NETWORK_BASE
 
-        # Initialize an indexer
-    Given an indexer IDX connected to base node BASE
-
-        # Initialize the wallet daemon
+    # Initialize the wallet daemon
     Given a wallet daemon WALLET_D connected to indexer IDX
 
-        # Create two accounts to test sending the tokens
+    # Create two accounts to test sending the tokens
     When I create an account ACC via the wallet daemon WALLET_D with 10000 free coins
 
         # Mint a new account NFT
diff --git a/integration_tests/tests/steps/indexer.rs b/integration_tests/tests/steps/indexer.rs
index fe426df65..7f559be91 100644
--- a/integration_tests/tests/steps/indexer.rs
+++ b/integration_tests/tests/steps/indexer.rs
@@ -84,6 +84,17 @@ async fn start_indexer(world: &mut TariWorld, indexer_name: String, bn_name: Str
     spawn_indexer(world, indexer_name, bn_name).await;
 }
 
+#[given(expr = "an indexer {word} connected to a base node")]
+async fn start_indexer_connected_to_a_base_node(world: &mut TariWorld, indexer_name: String) {
+    let bn_name = world
+        .base_nodes
+        .keys()
+        .next()
+        .cloned()
+        .expect("no base nodes have been started");
+    spawn_indexer(world, indexer_name, bn_name).await;
+}
+
 #[given(expr = "{word} indexer GraphQL request works")]
 async fn works_indexer_graphql(world: &mut TariWorld, indexer_name: String) {
     let indexer: &mut IndexerProcess = world.indexers.get_mut(&indexer_name).unwrap();
diff --git a/integration_tests/tests/steps/miner.rs b/integration_tests/tests/steps/miner.rs
index e33404c69..15dc36c7d 100644
--- a/integration_tests/tests/steps/miner.rs
+++ b/integration_tests/tests/steps/miner.rs
@@ -12,7 +12,7 @@ async fn create_miner(world: &mut TariWorld, miner_name: String, bn_name: String
 }
 
 #[when(expr = "miner {word} mines {int} new blocks")]
-async fn miner_mines_new_blocks(world: &mut TariWorld, miner_name: String, num_blocks: u64) {
+pub async fn miner_mines_new_blocks(world: &mut TariWorld, miner_name: String, num_blocks: u64) {
     let bn = world
         .base_nodes
         .values()
diff --git a/integration_tests/tests/steps/mod.rs b/integration_tests/tests/steps/mod.rs
index ba2e3364e..ba2e204bd 100644
--- a/integration_tests/tests/steps/mod.rs
+++ b/integration_tests/tests/steps/mod.rs
@@ -5,6 +5,7 @@ mod base_node;
 mod common;
 mod indexer;
 mod miner;
+mod network;
 mod validator_node;
 mod wallet;
 mod wallet_daemon;
diff --git a/integration_tests/tests/steps/network.rs b/integration_tests/tests/steps/network.rs
new file mode 100644
index 000000000..69f741806
--- /dev/null
+++ b/integration_tests/tests/steps/network.rs
@@ -0,0 +1,46 @@
+//    Copyright 2024 The Tari Project
+//    SPDX-License-Identifier: BSD-3-Clause
+
+use cucumber::given;
+use integration_tests::{
+    base_node::spawn_base_node,
+    miner::register_miner_process,
+    validator_node::spawn_validator_node,
+    wallet::spawn_wallet,
+};
+
+use crate::{
+    steps::{miner, validator_node, wallet},
+    TariWorld,
+};
+
+#[given(expr = "a network with registered validator {word} and wallet daemon {word}")]
+async fn start_a_network(world: &mut TariWorld, vn_name: String, walletd_name: String) {
+    const BASE_NODE_NAME: &str = "NETWORK_BASE";
+    const WALLET_NAME: &str = "NETWORK_CONSOLE_WALLET";
+    const MINER_NAME: &str = "NETWORK_MINER";
+
+    spawn_base_node(world, BASE_NODE_NAME.to_string()).await;
+    spawn_wallet(world, WALLET_NAME.to_string(), BASE_NODE_NAME.to_string()).await;
+    register_miner_process(
+        world,
+        MINER_NAME.to_string(),
+        BASE_NODE_NAME.to_string(),
+        WALLET_NAME.to_string(),
+    );
+    let vn = spawn_validator_node(
+        world,
+        vn_name.clone(),
+        BASE_NODE_NAME.to_string(),
+        walletd_name,
+        format!("{}_claim_fee", vn_name),
+    )
+    .await;
+    world.validator_nodes.insert(vn_name.clone(), vn);
+
+    miner::miner_mines_new_blocks(world, MINER_NAME.to_string(), 6).await;
+    wallet::check_balance(world, WALLET_NAME.to_string(), 20, "T".to_string()).await;
+    validator_node::send_vn_registration_with_claim_wallet(world, vn_name.clone(), WALLET_NAME.to_string()).await;
+    miner::miner_mines_new_blocks(world, MINER_NAME.to_string(), 16).await;
+    validator_node::assert_vn_is_registered(world, vn_name).await;
+}
diff --git a/integration_tests/tests/steps/validator_node.rs b/integration_tests/tests/steps/validator_node.rs
index a9673551b..e896dced0 100644
--- a/integration_tests/tests/steps/validator_node.rs
+++ b/integration_tests/tests/steps/validator_node.rs
@@ -148,7 +148,7 @@ async fn given_validator_connects_to_other_vns(world: &mut TariWorld, name: Stri
 }
 
 #[when(expr = "validator node {word} sends a registration transaction to base wallet {word}")]
-async fn send_vn_registration_with_claim_wallet(world: &mut TariWorld, vn_name: String, base_wallet_name: String) {
+pub async fn send_vn_registration_with_claim_wallet(world: &mut TariWorld, vn_name: String, base_wallet_name: String) {
     let vn = world.get_validator_node(&vn_name);
 
     let mut base_layer_wallet = world.get_wallet(&base_wallet_name).create_client().await;
@@ -220,7 +220,7 @@ async fn assert_all_vns_are_registered(world: &mut TariWorld) {
 }
 
 #[then(expr = "the validator node {word} is listed as registered")]
-async fn assert_vn_is_registered(world: &mut TariWorld, vn_name: String) {
+pub async fn assert_vn_is_registered(world: &mut TariWorld, vn_name: String) {
     // create a base node client
     let vn = world.get_validator_node(&vn_name);
     let mut base_node_client: GrpcBaseNodeClient = get_base_node_client(vn.base_node_grpc_port);
diff --git a/integration_tests/tests/steps/wallet.rs b/integration_tests/tests/steps/wallet.rs
index 5c2fe4eaa..7d1887ff4 100644
--- a/integration_tests/tests/steps/wallet.rs
+++ b/integration_tests/tests/steps/wallet.rs
@@ -73,7 +73,7 @@ async fn when_i_burn_on_wallet(
 }
 
 #[when(expr = "wallet {word} has at least {int} {word}")]
-async fn check_balance(world: &mut TariWorld, wallet_name: String, balance: u64, units: String) {
+pub async fn check_balance(world: &mut TariWorld, wallet_name: String, balance: u64, units: String) {
     let wallet = world
         .wallets
         .get(&wallet_name)