trac-msb 0.2.18 → 0.2.20

package/README.md

@@ -18,9 +18,9 @@ The MSB leverages the [Pear Runtime and Holepunch](https://pears.com/).
 
 Node.js is required to run the application. Before installing Node.js, refer to the official [Node.js documentation](https://nodejs.org) for the latest recommended version and installation instructions. For this project, Node.js v22.22.0 (LTS) and npm 11.6.1 or newer are compatible.
 
-The Pear Runtime CLI is required to run the application. Before installing Pear, refer to the official [Pear documentation](https://docs.pears.com/guides/getting-started) for the latest recommended version and installation instructions. For this project, the latest Pear CLI is compatible.
+MSB supports both Pear v2 and Pear v3. Its Pear runner uses `pear run` with Pear v2 and the embedded [`pear-runtime`](https://docs.pears.com/reference/pear/runtime/) module with Pear v3.
 
-Install Pear globally:
+The Pear CLI is required for Pear v2 and for Pear deployment commands. Pear v3 can run MSB through the embedded module without a globally installed CLI. Install the CLI when it is needed:
 
 ```sh
 npm install -g pear
@@ -53,6 +53,23 @@ npm install -g bare
 
 Runtime entry points cover CLI-driven runs (`start`, `rpc`) and `.env`-aware runs (`env`, `env-rpc`). Each section below lists the accepted configuration inputs.
 
+### Startup input validation
+
+Startup input is validated before MSB finishes booting. This applies to direct CLI flags and to the `.env` / inline environment-variable entry points, because those scripts pass the same flags through the Pear v2/v3 runner.
+
+- `--network` / `NETWORK` must be one of `mainnet`, `development`, `testnet1`, or `testnet` (`testnet` is treated as an alias for `testnet1`).
+- `--stores-directory` / `STORES_DIRECTORY` must be a non-empty string.
+- `--host` / `MSB_HOST` must be a non-empty string when RPC mode is enabled.
+- `--port` / `MSB_PORT` must be an integer in range `1-65535` when RPC mode is enabled.
+
+MSB also validates the high-risk overrideable config values that are normalized into shared runtime state before startup:
+
+- `bootstrap` must be a 32-byte hex string or `Buffer`.
+- `channel` must be a string or `Buffer` with length `1-32` bytes.
+- `storesDirectory`, `host`, `port`, and `dhtBootstrap` overrides are validated before the node starts.
+
+When one of these values is invalid, startup fails immediately with a field-specific error instead of silently falling back.
+
 ### Interactive regular node
 
 #### Regular node with .env file
@@ -87,6 +104,8 @@ This run persists data under `${STORES_DIRECTORY}` (defaults to `stores` under t
 npm run start -- --stores-directory <stores_directory> --network testnet
 ```
 
+Supported network values are `mainnet`, `development`, `testnet1`, and `testnet` (`testnet` maps to `testnet1`).
+
 ### RPC-enabled node
 
 #### RPC with .env file
@@ -119,6 +138,8 @@ Override any combination of `STORES_DIRECTORY`, `MSB_HOST`, `MSB_PORT`, or `NETW
 npm run rpc --host=<host> --port=<port> -- --stores-directory <stores_directory> --network <network>
 ```
 
+Supported network values are `mainnet`, `development`, `testnet1`, and `testnet` (`testnet` maps to `testnet1`). Invalid `--host`, `--port`, `--stores-directory`, or `--network` values fail before the RPC node starts.
+
 ## Docker usage
 
 You can run the RPC node in a containerized environment using the provided `docker-compose.yml` file. The `msb-rpc` service is already wired up. You usually only need to tweak these variables:
@@ -216,3 +237,42 @@ Stop the service with `docker compose stop msb-rpc`, remove the stack entirely w
 
 - **Dependency install failures** – confirm you are on Node.js v22.22.0 (LTS) and npm ≥ 11.6.1. If packages still fail to build, clear artifacts (`rm -rf node_modules package-lock.json && npm install`) and rerun `npm run test:unit:all`.
 - **Unit tests fail only in one runtime** – run the targeted commands (`npm run test:unit:node` or `npm run test:unit:bare`) to isolate regressions, then inspect `tests/unit/unit.test.js` for the failing cases.
+
+## Development
+
+### VS Code
+
+Open the repository root in VS Code so the editor can resolve the local `eslint` dependency, the root `eslint.config.js`, and the existing debugger launch configurations in `.vscode/launch.json`.
+
+Install these extensions:
+
+- `dbaeumer.vscode-eslint` (microsoft.com)
+
+For linting, add the following to your workspace or user `.vscode/settings.json`:
+
+```json
+{
+  "editor.formatOnSave": false,
+  "editor.codeActionsOnSave": {
+    "source.fixAll.eslint": "explicit"
+  },
+  "eslint.useFlatConfig": true,
+  "eslint.workingDirectories": [
+    {
+      "mode": "auto"
+    }
+  ],
+  "[javascript]": {
+    "editor.defaultFormatter": "dbaeumer.vscode-eslint"
+  }
+}
+```
+
+### Linting and tests
+
+Use these commands during development:
+
+- `npm run lint` checks the full repository with ESLint.
+- `npm run lint:fix` applies ESLint autofixes where possible.
+- `npm run test:unit:all` runs both unit suites and is the main pre-commit test command.
+- `npm run test:acceptance` runs the RPC acceptance test suite.

package/SECURITY.md

@@ -4,12 +4,15 @@
 
 The following table shows which versions of this project are currently receiving security updates.
 
-| Version | Supported          |
-| -------- | ------------------ |
-| 0.2.x    | :white_check_mark: |
-| < 0.2    | :x:                |
-
-Older versions (< 0.2.x) are no longer supported.  
+| Version  | Supported          | Pear compatibility |
+| -------- | ------------------ | ------------------ |
+| 0.2.19   | :white_check_mark: | Pear v2 and v3     |
+| 0.2.18   | :white_check_mark: | Pear v2 only       |
+| 0.2.17   | :white_check_mark: | Pear v2 only       |
+| main     | :warning: unstable | Pear v2 and v3     |
+| < 0.2.17 | :x:               | N/A                |
+
+Versions older than 0.2.17 are deprecated.
 Please upgrade to the latest release to ensure you receive security fixes.
 
 ---

package/cli/commandHandler.js

@@ -0,0 +1,272 @@
+import { randomBytes } from "hypercore-crypto";
+import { Handlers } from "./handlers.js";
+import { isHexString } from "../src/utils/helpers.js";
+import { bigIntToDecimalString } from "../src/utils/amountSerialization.js";
+
+export const COMMANDS = {
+    HELP: "/help",
+    EXIT: "/exit",
+    ADD_ADMIN: "/add_admin",
+    ADD_ADMIN_RECOVERY: "/add_admin --recovery",
+    ADD_WHITELIST: "/add_whitelist",
+    ADD_WRITER: "/add_writer",
+    REMOVE_WRITER: "/remove_writer",
+    CORE: "/core",
+    INDEXERS_LIST: "/indexers_list",
+    VALIDATOR_POOL: "/validator_pool",
+    STATS: "/stats",
+    BALANCE_MIGRATION: "/balance_migration",
+    DISABLE_INITIALIZATION: "/disable_initialization",
+    NODE_STATUS: "/node_status",
+    ADD_INDEXER: "/add_indexer",
+    REMOVE_INDEXER: "/remove_indexer",
+    BAN_WRITER: "/ban_writer",
+    DEPLOYMENT: "/deployment",
+    GET_VALIDATOR_ADDR: "/get_validator_addr",
+    GET_DEPLOYMENT: "/get_deployment",
+    GET_TX_INFO: "/get_tx_info",
+    TRANSFER: "/transfer",
+    GET_BALANCE: "/get_balance",
+    GET_LICENSE_NUMBER: "/get_license_number",
+    GET_LICENSE_ADDRESS: "/get_license_address",
+    GET_LICENSE_COUNT: "/get_license_count",
+    GET_TXV: "/get_txv",
+    GET_FEE: "/get_fee",
+    CONFIRMED_LENGTH: "/confirmed_length",
+    UNCONFIRMED_LENGTH: "/unconfirmed_length",
+    GET_TXS_HASHES: "/get_txs_hashes",
+    GET_TX_DETAILS: "/get_tx_details",
+    GET_EXTENDED_TX_DETAILS: "/get_extended_tx_details"
+};
+
+export class CommandHandler {
+    #msb;
+    #closeCli;
+    #wallet;
+    #handlers;
+    #pendingConfirmation = null;
+
+    constructor({ config, msb, handleClose, wallet }) {
+        this.#msb = msb;
+        this.#closeCli = handleClose;
+        this.#wallet = wallet;
+        this.#handlers = new Handlers(msb, config);
+    }
+
+    async handle(input) {
+        if (this.#pendingConfirmation !== null) {
+            return this.#handlePendingConfirmation(input);
+        }
+
+        const [command, ...parts] = input.split(" ");
+        const context = { command, input, parts };
+        const handlers = this.#getHandlers();
+        const handler = handlers.find(({ evaluate }) => evaluate(context));
+
+        if (handler) {
+            return handler.process(context);
+        }
+    }
+
+    #getHandlers() {
+        return [
+            {
+                evaluate: ({ command }) => command === COMMANDS.HELP,
+                process: async () => {
+                    this.#msb.printHelp();
+                }
+            },
+            {
+                evaluate: ({ command }) => command === COMMANDS.EXIT,
+                process: async () => {
+                    await this.#closeCli();
+                    await this.#msb.close();
+                }
+            },
+            {
+                evaluate: ({ input }) => input === COMMANDS.ADD_ADMIN_RECOVERY,
+                process: async () => this.#msb.handleAdminRecovery()
+            },
+            {
+                evaluate: ({ command }) => command === COMMANDS.ADD_ADMIN,
+                process: async () => this.#msb.handleAdminCreation()
+            },
+            {
+                evaluate: ({ command }) => command === COMMANDS.ADD_WHITELIST,
+                process: async () => this.#msb.handleWhitelistOperations()
+            },
+            {
+                evaluate: ({ command }) => command === COMMANDS.ADD_WRITER,
+                process: async () => this.#msb.requestWriterRole(true)
+            },
+            {
+                evaluate: ({ command }) => command === COMMANDS.REMOVE_WRITER,
+                process: async () => this.#msb.requestWriterRole(false)
+            },
+            {
+                evaluate: ({ command }) => command === COMMANDS.CORE,
+                process: async () => this.#handlers.handleCoreInfo()
+            },
+            {
+                evaluate: ({ command }) => command === COMMANDS.INDEXERS_LIST,
+                process: async () => console.log(await this.#msb.state.getIndexersEntry())
+            },
+            {
+                evaluate: ({ command }) => command === COMMANDS.VALIDATOR_POOL,
+                process: async () => this.#msb.network.validatorConnectionManager.prettyPrint()
+            },
+            {
+                evaluate: ({ command }) => command === COMMANDS.STATS,
+                process: async () => this.#msb.verifyDag()
+            },
+            {
+                evaluate: ({ command }) => command === COMMANDS.BALANCE_MIGRATION,
+                process: async () => this.#msb.balanceMigrationOperation()
+            },
+            {
+                evaluate: ({ command }) => command === COMMANDS.DISABLE_INITIALIZATION,
+                process: async () => this.#msb.disableInitialization()
+            },
+            {
+                evaluate: ({ input }) => input.startsWith(COMMANDS.NODE_STATUS),
+                process: async ({ parts }) => this.#handlers.handleNodeStatus(parts[0])
+            },
+            {
+                evaluate: ({ input }) => input.startsWith(COMMANDS.ADD_INDEXER),
+                process: async ({ parts }) => this.#msb.updateWriterToIndexerRole(parts[0], true)
+            },
+            {
+                evaluate: ({ input }) => input.startsWith(COMMANDS.REMOVE_INDEXER),
+                process: async ({ parts }) => this.#msb.updateWriterToIndexerRole(parts[0], false)
+            },
+            {
+                evaluate: ({ input }) => input.startsWith(COMMANDS.BAN_WRITER),
+                process: async ({ parts }) => this.#msb.banValidator(parts[0])
+            },
+            {
+                evaluate: ({ input }) => input.startsWith(COMMANDS.DEPLOYMENT),
+                process: async ({ parts }) => {
+                    const channel = parts[1] || randomBytes(32).toString("hex");
+                    if (!isHexString(channel, 64)) {
+                        throw new Error("Channel must be a 32-byte hex string");
+                    }
+                    return this.#msb.deployBootstrap(parts[0], channel);
+                }
+            },
+            {
+                evaluate: ({ input }) => input.startsWith(COMMANDS.GET_VALIDATOR_ADDR),
+                process: async ({ parts }) => this.#handlers.handleValidatorAddress(parts[0])
+            },
+            {
+                evaluate: ({ input }) => input.startsWith(COMMANDS.GET_DEPLOYMENT),
+                process: async ({ parts }) => this.#handlers.handleDeployment(parts[0])
+            },
+            {
+                evaluate: ({ input }) => input.startsWith(COMMANDS.GET_TX_INFO),
+                process: async ({ parts }) => this.#handlers.handleTxInfo(parts[0])
+            },
+            {
+                evaluate: ({ input }) => input.startsWith(COMMANDS.TRANSFER),
+                process: async ({ parts }) => this.#queueTransferConfirmation(parts[0], parts[1])
+            },
+            {
+                evaluate: ({ input }) => input.startsWith(COMMANDS.GET_BALANCE),
+                process: async ({ parts }) => this.#handlers.handleBalance(parts[0] || this.#wallet?.address, parts[1])
+            },
+            {
+                evaluate: ({ input }) => input.startsWith(COMMANDS.GET_LICENSE_NUMBER),
+                process: async ({ parts }) => this.#handlers.handleLicenseNumber(parts[0])
+            },
+            {
+                evaluate: ({ input }) => input.startsWith(COMMANDS.GET_LICENSE_ADDRESS),
+                process: async ({ parts }) => this.#handlers.handleLicenseAddress(parseInt(parts[0]))
+            },
+            {
+                evaluate: ({ input }) => input.startsWith(COMMANDS.GET_LICENSE_COUNT),
+                process: async () => this.#handlers.handleLicenseCount()
+            },
+            {
+                evaluate: ({ input }) => input.startsWith(COMMANDS.GET_TXV),
+                process: async () => this.#handlers.handleTxv()
+            },
+            {
+                evaluate: ({ input }) => input.startsWith(COMMANDS.GET_FEE),
+                process: async () => this.#handlers.handleFee()
+            },
+            {
+                evaluate: ({ input }) => input.startsWith(COMMANDS.CONFIRMED_LENGTH),
+                process: async () => this.#handlers.handleConfirmedLength()
+            },
+            {
+                evaluate: ({ input }) => input.startsWith(COMMANDS.UNCONFIRMED_LENGTH),
+                process: async () => this.#handlers.handleUnconfirmedLength()
+            },
+            {
+                evaluate: ({ input }) => input.startsWith(COMMANDS.GET_TXS_HASHES),
+                process: async ({ parts }) => this.#handlers.handleTxHashes(
+                    parseInt(parts[0]),
+                    parseInt(parts[1])
+                )
+            },
+            {
+                evaluate: ({ input }) => input.startsWith(COMMANDS.GET_TX_DETAILS),
+                process: async ({ parts }) => this.#handlers.handleTxDetails(parts[0])
+            },
+            {
+                evaluate: ({ input }) => input.startsWith(COMMANDS.GET_EXTENDED_TX_DETAILS),
+                process: async ({ parts }) => this.#handlers.handleExtendedTxDetails(parts[0], parts[1] === "true")
+            }
+        ];
+    }
+
+    async #handlePendingConfirmation(input) {
+        const normalizedInput = input.trim().toLowerCase();
+        const pendingConfirmation = this.#pendingConfirmation;
+
+        if (normalizedInput === "y" || normalizedInput === "yes") {
+            this.#pendingConfirmation = null;
+
+            try {
+                return await pendingConfirmation.onConfirm();
+            } catch (error) {
+                const errorMessage = typeof error === "object" && error !== null && "message" in error
+                    ? error.message
+                    : `${error}`;
+                console.error(`Transaction submission failed: ${errorMessage}`);
+                console.log("Try again or use /help.");
+            }
+
+            return;
+        }
+
+        if (normalizedInput === "n" || normalizedInput === "no") {
+            this.#pendingConfirmation = null;
+            return pendingConfirmation.onDecline();
+        }
+
+        console.log('Invalid input. Please answer "y" or "n".');
+        console.log(pendingConfirmation.prompt);
+    }
+
+    async #queueTransferConfirmation(recipientAddress, amount) {
+        const preparedTransfer = await this.#msb.prepareTransferOperation(recipientAddress, amount);
+
+        console.info("Transfer Details:");
+        if (preparedTransfer.isSelfTransfer) {
+            console.info("Self transfer - only fee will be deducted");
+        }
+        console.info(`Amount: ${bigIntToDecimalString(preparedTransfer.amountBigInt)}`);
+        console.info(`Estimated transaction fee: ${bigIntToDecimalString(preparedTransfer.feeBigInt)}`);
+        console.info(`Total transaction cost: ${bigIntToDecimalString(preparedTransfer.totalDeductedAmount)}`);
+        console.info(`Current balance: ${bigIntToDecimalString(preparedTransfer.senderBalance)}`);
+        console.info(`Balance after transaction: ${bigIntToDecimalString(preparedTransfer.expectedNewBalance)}`);
+
+        this.#pendingConfirmation = {
+            prompt: "Do you want to proceed? (y/n)",
+            onConfirm: async () => this.#msb.submitPreparedTransferOperation(preparedTransfer),
+            onDecline: async () => this.#msb.printHelp()
+        };
+
+        console.log(this.#pendingConfirmation.prompt);
+    }
+}

package/cli/handlers.js

@@ -0,0 +1,210 @@
+import { ZERO_WK } from "../src/utils/buffer.js";
+import { bigIntToDecimalString, bufferToBigInt } from "../src/utils/amountSerialization.js";
+import { EntryType } from "../src/utils/constants.js";
+import { bufferToAddress } from "../src/core/state/utils/address.js";
+import deploymentEntryUtils from "../src/core/state/utils/deploymentEntry.js";
+import { safeDecodeApplyOperation } from "../src/utils/protobuf/operationHelpers.js";
+
+export class Handlers {
+    #msb
+    #config
+
+    constructor(msb, config) {
+        this.#msb = msb
+        this.#config = config
+    }
+
+    async handleNodeStatus(address) {
+        const nodeEntry = await this.#msb.state.getNodeEntry(address)
+        if (nodeEntry) {
+            const licenseValue = nodeEntry.license.readUInt32BE(0)
+            const licenseDisplay = licenseValue === 0 ? "N/A" : licenseValue.toString()
+            console.log("Node Status:", {
+                Address: address,
+                WritingKey: nodeEntry.wk.toString("hex"),
+                IsWhitelisted: nodeEntry.isWhitelisted,
+                IsWriter: nodeEntry.isWriter,
+                IsIndexer: nodeEntry.isIndexer,
+                License: licenseDisplay,
+                StakedBalance: bigIntToDecimalString(bufferToBigInt(nodeEntry.stakedBalance)),
+                Balance: bigIntToDecimalString(bufferToBigInt(nodeEntry.balance))
+            })
+            return {
+                address,
+                writingKey: nodeEntry.wk.toString("hex"),
+                isWhitelisted: nodeEntry.isWhitelisted,
+                isWriter: nodeEntry.isWriter,
+                isIndexer: nodeEntry.isIndexer,
+                license: licenseDisplay,
+                stakedBalance: bigIntToDecimalString(bufferToBigInt(nodeEntry.stakedBalance)),
+                balance: bigIntToDecimalString(bufferToBigInt(nodeEntry.balance))
+            }
+        }
+
+        console.log("Node Status:", {
+            WritingKey: ZERO_WK.toString("hex"),
+            IsWhitelisted: false,
+            IsWriter: false,
+            IsIndexer: false,
+            license: "N/A",
+            stakedBalance: "0"
+        })
+    }
+
+    async handleCoreInfo() {
+        const admin = await this.#msb.state.getAdminEntry()
+        console.log("Admin:", admin ? {
+            address: admin.address,
+            writingKey: admin.wk.toString("hex")
+        } : null)
+
+        const formattedIndexers = await this.#msb.state.getIndexersEntry().then(entry => entry ? entry : null)
+        if (!formattedIndexers || (Array.isArray(formattedIndexers) && formattedIndexers.length === 0)) {
+            console.log("Indexers: no indexers")
+        } else {
+            console.log("Indexers:", formattedIndexers)
+        }
+    }
+
+    async handleValidatorAddress(wkHexString) {
+        const payload = await this.#msb.state.getSigned(EntryType.WRITER_ADDRESS + wkHexString)
+        if (payload === null) {
+            console.log(`No address assigned to the writer key: ${wkHexString}`)
+        } else {
+            console.log(
+                `Address assigned to the writer key: ${wkHexString} - ${bufferToAddress(payload, this.#config.addressPrefix)}`
+            )
+        }
+    }
+
+    async handleDeployment(bootstrapHex) {
+        const deploymentEntry = await this.#msb.state.getRegisteredBootstrapEntry(bootstrapHex)
+        if (deploymentEntry) {
+            const decodedDeploymentEntry = deploymentEntryUtils.decode(deploymentEntry, this.#config.addressLength)
+            const txhash = decodedDeploymentEntry.txHash.toString("hex")
+            console.log(`Bootstrap deployed under transaction hash: ${txhash}`)
+            const payload = await this.#msb.state.getSigned(txhash)
+            if (payload) {
+                const decoded = safeDecodeApplyOperation(payload)
+                console.log("Decoded Bootstrap Deployment Payload:", decoded)
+            } else {
+                console.log(`No payload found for transaction hash: ${txhash}`)
+            }
+        } else {
+            console.log(`No deployment found for bootstrap: ${bootstrapHex}`)
+        }
+    }
+
+    async handleTxInfo(txHash) {
+        const txInfo = await this.#msb.getConfirmedTxInfo(txHash)
+        if (txInfo) {
+            console.log(`Payload for transaction hash ${txHash}:`, txInfo.decoded)
+        } else {
+            console.log(`No information found for transaction hash: ${txHash}`)
+        }
+    }
+
+    async handleLicenseNumber(address) {
+        const nodeEntry = await this.#msb.state.getNodeEntry(address)
+        if (nodeEntry) {
+            console.log({
+                Address: address,
+                License: bufferToBigInt(nodeEntry.license).toString()
+            })
+        }
+    }
+
+    async handleLicenseAddress(licenseId) {
+        if (isNaN(licenseId) || licenseId < 0) {
+            console.log("Invalid license ID. Please provide a valid non-negative number.")
+            return
+        }
+
+        const address = await this.#msb.state.getAddressByLicenseId(licenseId)
+        if (address) {
+            console.log({
+                LicenseId: licenseId,
+                Address: address
+            })
+        } else {
+            console.log(`No address found for license ID: ${licenseId}`)
+        }
+    }
+
+    async handleLicenseCount() {
+        if (!await this.#msb.state.isAdmin()) {
+            throw new Error("Cannot perform this operation - you are not the admin!.")
+        }
+
+        const licenseCount = await this.#msb.state.getLicenseCount()
+        console.log({
+            LicensesCount: licenseCount
+        })
+    }
+
+    handleFee() {
+        const fee = this.#msb.handleGetFee()
+        console.log("Current FEE:", bigIntToDecimalString(fee));
+    }
+
+    async handleBalance(address, confirmedFlag) {
+        const nodeInfo = await this.#msb.getBalance(address, confirmedFlag !== "false");
+
+        if (nodeInfo) {
+            console.log({
+                Address: address,
+                Balance: bigIntToDecimalString(BigInt(nodeInfo.balance))
+            });
+            return nodeInfo;
+        }
+
+        console.log("Node Entry:", {
+            WritingKey: ZERO_WK.toString("hex"),
+            IsWhitelisted: false,
+            IsWriter: false,
+            IsIndexer: false,
+            balance: bigIntToDecimalString(0n)
+        });
+    }
+
+    async handleTxv() {
+        const txv = await this.#msb.getTxv();
+        console.log("Current TXV:", txv);
+        return txv;
+    }
+
+    handleConfirmedLength() {
+        const confirmedLength = this.#msb.getConfirmedLength();
+        console.log("Confirmed_length:", confirmedLength);
+        return confirmedLength;
+    }
+
+    handleUnconfirmedLength() {
+        const unconfirmedLength = this.#msb.getUnconfirmedLength();
+        console.log("Unconfirmed_length:", unconfirmedLength);
+        return unconfirmedLength;
+    }
+
+    async handleTxHashes(start, end) {
+        return this.#msb.getTxHashes(start, end);
+    }
+
+    async handleTxDetails(hash) {
+        const txDetails = await this.#msb.getTxDetails(hash);
+        if (!txDetails) {
+            console.log(`No payload found for tx hash: ${hash}`);
+            return null;
+        }
+
+        return txDetails;
+    }
+
+    async handleExtendedTxDetails(hash, confirmed) {
+        const txDetails = await this.#msb.getExtendedTxDetails(hash, confirmed);
+        if (!txDetails) {
+            throw new Error(`No payload found for tx hash: ${hash}`);
+        }
+
+        return txDetails;
+    }
+}