trac-msb 0.2.9 → 0.2.10

package/msb.mjs

@@ -1,31 +1,14 @@
 import { MainSettlementBus } from './src/index.js';
 import { startRpcServer } from './rpc/rpc_server.js';
-import { createConfig, ENV } from './src/config/env.js';
+import { isRpcEnabled, resolveConfig } from './src/config/args.js';
 
-const pearApp = typeof Pear !== 'undefined' ? (Pear.app ?? Pear.config) : undefined;
-const runtimeArgs = typeof process !== 'undefined' ? process.argv.slice(2) : [];
-const args = pearApp?.args ?? runtimeArgs;
-const runRpc = args.includes('--rpc');
-const storeName = pearApp?.args?.[0] ?? runtimeArgs[0]
-
-const rpc = {
-    storeName: pearApp?.args?.[0] ?? runtimeArgs[0],
-    enableWallet: false,
-    enableInteractiveMode: false
-}
-
-const options = args.includes('--rpc') ? rpc : { storeName }
-const config = createConfig(ENV.MAINNET, options)
+const config = resolveConfig()
 const msb = new MainSettlementBus(config);
 
 msb.ready().then(async () => {
-    if (runRpc) {
+    if (isRpcEnabled()) {
         console.log('Starting RPC server...');
-        const portIndex = args.indexOf('--port');
-        const port = (portIndex !== -1 && args[portIndex + 1]) ? parseInt(args[portIndex + 1], 10) : 5000;
-        const hostIndex = args.indexOf('--host');
-        const host = (hostIndex !== -1 && args[hostIndex + 1]) ? args[hostIndex + 1] : 'localhost';
-        startRpcServer(msb, config , host, port);
+        startRpcServer(msb, config);
     } else {
         console.log('RPC server will not be started.');
         msb.interactiveMode();

package/package.json

@@ -1,20 +1,18 @@
 {
   "name": "trac-msb",
   "main": "msb.mjs",
-  "version": "0.2.9",
+  "version": "0.2.10",
   "pear": {
     "name": "trac-msb",
     "type": "terminal"
   },
   "type": "module",
   "scripts": {
-    "dev": "pear run -d .",
-    "dev-rpc": "pear run -d . ${npm_config_store} --rpc --port ${npm_config_port}",
-    "prod": "NODE_OPTIONS='--max-old-space-size=4096' pear run . ${npm_config_store}",
-    "prod-rpc": "NODE_OPTIONS='--max-old-space-size=4096' pear run . ${npm_config_store} --rpc --host ${npm_config_host} --port ${npm_config_port}",
-    "env-prod": "if [ -f .env ]; then set -a; . ./.env; set +a; fi; NODE_OPTIONS='--max-old-space-size=4096' pear run . ${MSB_STORE:-node-store}",
-    "env-prod-rpc": "if [ -f .env ]; then set -a; . ./.env; set +a; fi; NODE_OPTIONS='--max-old-space-size=4096' pear run . ${MSB_STORE:-rpc-node-store} --rpc --host ${MSB_HOST:-127.0.0.1} --port ${MSB_PORT:-5000}",
-    "env-prod-rpc-docker": "if [ -f .env ]; then set -a; . ./.env; set +a; fi; NODE_OPTIONS='--max-old-space-size=4096' node msb.mjs ${MSB_STORE:-rpc-node-store} --rpc --host 0.0.0.0 --port ${MSB_PORT:-5000}",
+    "start": "NODE_OPTIONS='--max-old-space-size=4096' pear run .",
+    "rpc": "NODE_OPTIONS='--max-old-space-size=4096' pear run . --rpc --host ${npm_config_host} --port ${npm_config_port}",
+    "env": "if [ -f .env ]; then set -a; . ./.env; set +a; fi; NODE_OPTIONS='--max-old-space-size=4096' pear run . --stores-directory ${STORES_DIRECTORY:-stores} --network ${NETWORK:-mainnet}",
+    "env-rpc": "if [ -f .env ]; then set -a; . ./.env; set +a; fi; NODE_OPTIONS='--max-old-space-size=4096' pear run . --stores-directory ${STORES_DIRECTORY:-stores} --rpc --host ${MSB_HOST:-127.0.0.1} --port ${MSB_PORT:-5000} --network ${NETWORK:-mainnet}",
+    "env-rpc-docker": "if [ -f .env ]; then set -a; . ./.env; set +a; fi; NODE_OPTIONS='--max-old-space-size=4096' node msb.mjs --stores-directory ${STORES_DIRECTORY:-stores} --rpc --host 0.0.0.0 --port ${MSB_PORT:-5000} --network ${NETWORK:-mainnet}",
     "protobuf": "node scripts/generate-protobufs.js",
     "test:acceptance": "node --experimental-vm-modules node_modules/jest/bin/jest.js --testTimeout=200000 tests/acceptance/v1/rpc.test.mjs --runInBand",
     "test:integration": "brittle-node -t 1200000 tests/integration/integration.test.js",
@@ -44,12 +42,13 @@
     "hypercore-crypto": "3.6.1",
     "hyperdht": "6.27.0",
     "hyperswarm": "4.14.2",
+    "lodash": "^4.17.23",
     "protocol-buffers-encodings": "1.2.0",
     "protomux": "3.10.1",
     "protomux-wakeup": "2.4.0",
     "readline": "npm:bare-node-readline",
     "ready-resource": "1.1.2",
-    "trac-wallet": "1.0.1",
+    "trac-wallet": "1.0.2",
     "tty": "npm:bare-node-tty",
     "uuid": "^13.0.0"
   },

package/rpc/handlers.js

@@ -1,7 +1,17 @@
-import { decodeBase64Payload, isBase64, sanitizeBulkPayloadsRequestBody, sanitizeTransferPayload, validatePayloadStructure } from "./utils/helpers.js"
+import { 
+    decodeBase64Payload, 
+    isBase64, 
+    isValidTxHash, 
+    sanitizeBulkPayloadsRequestBody, 
+    sanitizeTransferPayload, 
+    validatePayloadStructure,
+    hasSpacesInUrl,
+    BroadcastError, 
+    ValidationError,
+    NotFoundError
+} from "./utils/helpers.js"
 import { MAX_SIGNED_LENGTH, ZERO_WK } from "./constants.js";
 import { buildRequestUrl } from "./utils/url.js";
-import { isHexString } from "../src/utils/helpers.js";
 import {
     getBalance,
     getTxv,
@@ -12,28 +22,41 @@ import {
     getTxHashes,
     getTxDetails,
     fetchBulkTxPayloads,
-    getExtendedTxDetails
+    getExtendedTxDetails,
 } from "./rpc_services.js";
 import { bufferToBigInt, licenseBufferToBigInt } from "../src/utils/amountSerialization.js";
 import { isAddressValid } from "../src/core/state/utils/address.js";
 import { getConfirmedParameter } from "./utils/confirmedParameter.js";
 
+export async function handleHealth({ msbInstance, respond }) {
+    try {
+        const isReady = msbInstance && msbInstance.state;
+        if (isReady) return respond(200, { ok: true });
+        throw new Error("RPC_OFFLINE");
+    } catch (error) {
+        respond(503, { error: "Could not connect to RPC server" });
+    }
+}
+
 export async function handleBalance({ req, respond, msbInstance }) {
     const url = buildRequestUrl(req);
     const parts = url.pathname.split("/").filter(Boolean);
     const address = parts[2];
 
-    const confirmedParam = getConfirmedParameter(url);
-    const confirmed = confirmedParam === null ? false : confirmedParam; // invalid -> fallback to unconfirmed
-
-    // TODO: VALIDATION? 
     if (!address) {
         respond(400, { error: 'Wallet address is required' });
         return;
     }
 
-    const nodeInfo = await getBalance(msbInstance, address, confirmed);
-    const balance = nodeInfo?.balance || 0;
+    const hrp = msbInstance.config.addressPrefix;
+    if (!isAddressValid(address, hrp)) {
+        respond(400, { error: 'Invalid account address format' });
+        return;
+    }
+
+    const nodeInfo = await getBalance(msbInstance, address, getConfirmedParameter(url) ?? false);
+    const balance = nodeInfo?.balance || "0";
+
     respond(200, { address, balance });
 }
 
@@ -54,44 +77,75 @@ export async function handleConfirmedLength({ msbInstance, respond }) {
 
 export async function handleBroadcastTransaction({ msbInstance, config, respond, req }) {
     let body = '';
+    const MAX_BODY_SIZE = 2_000_000;
+    let limitExceeded = false;
+
     req.on('data', chunk => {
+        if (limitExceeded) return;
         body += chunk.toString();
+        if (body.length > MAX_BODY_SIZE) {
+            limitExceeded = true;
+            respond(413, { error: 'Payload too large.' });
+            req.resume();
+        }
     });
 
     req.on('end', async () => {
+        if (limitExceeded) return;
+
         try {
-            const { payload } = JSON.parse(body);
+            if (!body) {
+                throw new ValidationError("Invalid JSON payload.");
+            }
+
+            let parsedBody;
+            try {
+                parsedBody = JSON.parse(body);
+            } catch (e) {
+                throw new ValidationError("Invalid JSON payload.");
+            }
+
+            const { payload } = parsedBody;
             if (!payload) {
-                return respond(400, { error: 'Payload is missing.' });
+                throw new ValidationError("Payload is missing.");
             }
 
             if (!isBase64(payload)) {
-                return respond(400, { error: 'Payload must be a valid base64 string.' });
+                throw new ValidationError("Payload must be a valid base64 string.");
             }
 
             const decodedPayload = decodeBase64Payload(payload);
             validatePayloadStructure(decodedPayload);
             const sanitizedPayload = sanitizeTransferPayload(decodedPayload);
+
             const result = await broadcastTransaction(msbInstance, config, sanitizedPayload);
             respond(200, { result });
-        } catch (error) {
-            let code = error instanceof SyntaxError ? 400 : 500;
-            let errorMsg = code === 400 ? 'Invalid JSON payload.' : 'An error occurred processing the transaction.'
 
-            if (error.message.includes("Failed to broadcast transaction after multiple attempts.")) {
+        } catch (error) {
+            let code = 500;
+            let errorMsg = 'An error occurred processing the transaction.';
+
+            if (error instanceof ValidationError || error instanceof SyntaxError) {
+                code = 400;
+                errorMsg = error.message;
+            } 
+            else if (error instanceof BroadcastError) {
                 code = 429;
-                errorMsg = "Failed to broadcast transaction after multiple attempts."
+                errorMsg = error.message;
+            }
+
+            if (code === 500) {
+                console.error('Error in handleBroadcastTransaction:', error);
             }
 
-            console.error('Error in handleBroadcastTransaction:', error);
-            // Use 400 for client errors (like bad JSON), 500 for server/command errors
             respond(code, { error: errorMsg });
         }
     });
 
     req.on('error', (err) => {
-        console.error('Stream error in handleBroadcastTransaction:', err);
-        respond(500, { error: 'Request stream failed during body transfer.' });
+        if (!limitExceeded) {
+            respond(500, { error: 'Request stream failed during body transfer.' });
+        }
     });
 }
 
@@ -104,18 +158,14 @@ export async function handleTxHashes({ msbInstance, respond, req }) {
     const startSignedLength = parseInt(startSignedLengthStr);
     const endSignedLength = parseInt(endSignedLengthStr);
 
-    // 1. Check if the parsed values are valid numbers
     if (isNaN(startSignedLength) || isNaN(endSignedLength)) {
         return respond(400, { error: 'Params must be integer' });
     }
 
-    // 2. Check for non-negative numbers
-    // The requirement is "non-negative," which includes 0.
     if (startSignedLength < 0 || endSignedLength < 0) {
         return respond(400, { error: 'Params must be non-negative' });
     }
 
-    // 3. endSignedLength must be >= startSignedLength
     if (endSignedLength < startSignedLength) {
         return respond(400, { error: 'endSignedLength must be greater than or equal to startSignedLength.' });
     }
@@ -124,13 +174,9 @@ export async function handleTxHashes({ msbInstance, respond, req }) {
         return respond(400, { error: `The max range for signedLength must be ${MAX_SIGNED_LENGTH}.` });
     }
 
-    // 4. Get current confirmed length
     const currentConfirmedLength = await getConfirmedLength(msbInstance);
-
-    // 5. Adjust the end index to not exceed the confirmed length.
     const adjustedEndLength = Math.min(endSignedLength, currentConfirmedLength)
 
-    // 6. Fetch txs hashes for the adjusted range, assuming the command takes start and end index.
     const { hashes } = await getTxHashes(msbInstance, startSignedLength, adjustedEndLength);
     respond(200, { hashes });
 }
@@ -141,57 +187,111 @@ export async function handleUnconfirmedLength({ msbInstance, respond }) {
 }
 
 export async function handleTransactionDetails({ msbInstance, respond, req }) {
-    const hash = req.url.split('/')[3];
-    const txDetails = await getTxDetails(msbInstance, hash);
-    respond(txDetails === null ? 404 : 200 , { txDetails });
+    if (hasSpacesInUrl(req.url)) {
+        return respond(400, { error: "Invalid transaction hash format" });
+    }
+
+    const url = buildRequestUrl(req);
+    const parts = url.pathname.split('/').filter(Boolean);
+    const rawHash = parts[parts.length - 1];
+
+    if (!rawHash || rawHash === 'tx') {
+        return respond(400, { error: "Transaction hash is required" });
+    }
+
+    const normalizedHash = rawHash.toLowerCase();
+    if (!isValidTxHash(normalizedHash)) {
+        return respond(400, { error: "Invalid transaction hash format" });
+    }
+
+    try {
+        const txDetails = await getTxDetails(msbInstance, normalizedHash);
+        respond(200, { txDetails });
+    } catch (error) {
+        let code = 500;
+        let errorMsg = "Internal error";
+
+        if (error instanceof NotFoundError) {
+            code = 404;
+            errorMsg = error.message;
+        }
+
+        respond(code, { [code === 404 ? 'txDetails' : 'error']: code === 404 ? null : errorMsg });
+    }
+}
+
+export async function handleTransactionExtendedDetails({ msbInstance, respond, req }) {
+    if (hasSpacesInUrl(req.url)) {
+        return respond(400, { error: "Invalid transaction hash format" });
+    }
+
+    const url = buildRequestUrl(req);
+    const pathParts = url.pathname.split('/').filter(Boolean);
+    const hashRaw = pathParts[pathParts.length - 1];
+
+    if (!hashRaw || hashRaw === 'details' || hashRaw === 'tx') {
+        return respond(400, { error: "Transaction hash is required" });
+    }
+
+    const hash = hashRaw.toLowerCase();
+    if (!isValidTxHash(hash)) {
+        return respond(400, { error: "Invalid transaction hash format" });
+    }
+
+    const confirmed = getConfirmedParameter(url);
+    if (confirmed === null) {
+        return respond(400, { error: 'Parameter "confirmed" must be exactly "true" or "false"' });
+    }
+
+    try {
+        const details = await getExtendedTxDetails(msbInstance, hash, confirmed);
+        respond(200, details);
+    } catch (error) {
+        let code = 500;
+        let errorMsg = 'An error occurred processing the request.';
+
+        if (error instanceof NotFoundError) {
+            code = 404;
+            errorMsg = error.message;
+        }
+
+        respond(code, { error: errorMsg });
+    }
 }
 
 export async function handleFetchBulkTxPayloads({ msbInstance, respond, req }) {
     let body = ''
     let bytesRead = 0;
     let limitBytes = 1_000_000;
-    let headersSent = false; // Add a flag to prevent double response
+    let headersSent = false;
 
     req.on('data', chunk => {
-        if (headersSent) return; // Stop processing if response has started/errored
-
+        if (headersSent) return;
         bytesRead += chunk.length;
         if (bytesRead > limitBytes) {
             respond(413, { error: 'Request body too large.' });
             headersSent = true;
-            req.destroy(); // Stop receiving data (GOOD PRACTICE)
+            req.destroy();
             return;
         }
         body += chunk.toString();
     });
 
     req.on('end', async () => {
-        if (headersSent) return; // Don't process if an error already occurred
-
+        if (headersSent) return;
 
         try {
-            if (body === null || body === '') {
-                return respond(400, { error: 'Missing payload.' });
+            if (!body) {
+                throw new ValidationError("Missing payload.");
             }
 
             const sanitizedPayload = sanitizeBulkPayloadsRequestBody(body);
-
-            if (sanitizedPayload === null) {
-                return respond(400, { error: 'Invalid payload.' });
+            if (!sanitizedPayload) {
+                throw new ValidationError("Invalid payload.");
             }
 
             const { hashes } = sanitizedPayload;
-
-            if (!Array.isArray(hashes) || hashes.length === 0) {
-                return respond(400, { error: 'Missing hash list.' });
-            }
-
-            if (hashes.length > 1500) {
-                return respond(413, { error: 'Too many hashes. Max 1500 allowed per request.' });
-            }
-
             const uniqueHashes = [...new Set(hashes)];
-
             const commandResult = await fetchBulkTxPayloads(msbInstance, uniqueHashes);
 
             const responseString = JSON.stringify(commandResult);
@@ -201,50 +301,23 @@ export async function handleFetchBulkTxPayloads({ msbInstance, respond, req }) {
 
             return respond(200, commandResult);
         } catch (error) {
-            console.error('Error in handleFetchBulkTxPayloads:', error);
-            // Use 400 for JSON errors, 500 otherwise
-            const code = error instanceof SyntaxError ? 400 : 500;
-            respond(code, { error: code === 400 ? 'Invalid request body format.' : 'An internal error occurred.' });
+            let code = 500;
+            let errorMsg = 'An internal error occurred.';
+
+            if (error instanceof ValidationError || error instanceof SyntaxError) {
+                code = 400;
+                errorMsg = error instanceof SyntaxError ? 'Invalid request body format.' : error.message;
+            }
+
+            respond(code, { error: errorMsg });
         }
     })
 
     req.on('error', (err) => {
-        console.error('Stream error in handleFetchBulkTxPayloads:', err);
         respond(500, { error: 'Request stream failed during body transfer.' });
     });
 }
 
-export async function handleTransactionExtendedDetails({ msbInstance, respond, req }) {
-    const url = buildRequestUrl(req);
-    const pathParts = url.pathname.split('/').filter(Boolean);
-    const hash = pathParts[3];
-
-    if (!hash) {
-        return respond(400, { error: "Transaction hash is required" });
-    }
-
-    if (isHexString(hash) === false || hash.length !== 64) {
-        return respond(400, { error: "Invalid transaction hash format" });
-    }
-
-    const confirmed = getConfirmedParameter(url);
-    if (confirmed === null) {
-        return respond(400, { error: 'Parameter "confirmed" must be exactly "true" or "false"' });
-    }
-
-    try {
-        const details = await getExtendedTxDetails(msbInstance, hash, confirmed);
-        respond(200, details);
-    } catch (error) {
-        if (error.message?.includes('No payload found for tx hash')) {
-            respond(404, { error: error.message });
-        } else {
-            console.error('Error in handleTransactionDetails:', error);
-            respond(500, { error: 'An error occurred processing the request.' });
-        }
-    }
-}
-
 export async function handleAccountDetails({ msbInstance, respond, req }) {
     const url = buildRequestUrl(req);
     const address = url.pathname.split('/').filter(Boolean)[2];
@@ -292,4 +365,4 @@ export async function handleAccountDetails({ msbInstance, respond, req }) {
         balance: bufferToBigInt(nodeEntry.balance).toString(),
         stakedBalance: bufferToBigInt(nodeEntry.stakedBalance).toString(),
     });
-}
+}

package/rpc/routes/v1.js

@@ -1,4 +1,5 @@
 import {
+    handleHealth,
     handleBalance,
     handleTxv,
     handleFee,
@@ -9,10 +10,11 @@ import {
     handleTransactionDetails,
     handleFetchBulkTxPayloads,
     handleTransactionExtendedDetails,
-    handleAccountDetails
+    handleAccountDetails,
 } from '../handlers.js';
 
 export const v1Routes = [
+    { method: 'GET', path: '/health', handler: handleHealth },
     { method: 'GET', path: '/balance', handler: handleBalance },
     { method: 'GET', path: '/txv', handler: handleTxv },
     { method: 'GET', path: '/fee', handler: handleFee },

package/rpc/rpc_server.js

@@ -1,10 +1,10 @@
 import { createServer } from "./create_server.js";
 
 // Called by msb.mjs file
-export function startRpcServer(msbInstance, config ,host, port) {
+export function startRpcServer(msbInstance, config) {
     const server = createServer(msbInstance, config)
 
-    return server.listen(port, host, () => {
-        console.log(`Running RPC with http at http://${host}:${port}`);
+    return server.listen(config.port, config.host, () => {
+        console.log(`Running RPC with http at http://${config.host}:${config.port}`);
     });
 }

package/rpc/rpc_services.js

@@ -5,10 +5,11 @@ import {
     normalizeTransferOperation
 } from "../src/utils/normalizers.js";
 import { get_confirmed_tx_info, get_unconfirmed_tx_info } from "../src/utils/cli.js";
-import {OperationType} from "../src/utils/constants.js";
+import { OperationType } from "../src/utils/constants.js";
 import b4a from "b4a";
 import PartialTransaction from "../src/core/network/protocols/shared/validators/PartialTransaction.js";
 import PartialTransfer from "../src/core/network/protocols/shared/validators/PartialTransfer.js";
+import { ValidationError, BroadcastError, NotFoundError } from "./utils/helpers.js";
 
 export async function getBalance(msbInstance, address, confirmed) {
     const state = msbInstance.state;
@@ -46,14 +47,15 @@ export async function getUnconfirmedLength(msbInstance) {
 
 export async function broadcastTransaction(msbInstance, config, payload) {
     if (!payload) {
-        throw new Error("Transaction payload is required for broadcasting.");
+        throw new ValidationError("Transaction payload is required for broadcasting.");
     }
+
     let normalizedPayload;
     let isValid = false;
     let hash;
 
-    const partialTransferValidator = new PartialTransfer(msbInstance.state, null , config);
-    const partialTransactionValidator = new PartialTransaction(msbInstance.state, null , config);
+    const partialTransferValidator = new PartialTransfer(msbInstance.state, null, config);
+    const partialTransactionValidator = new PartialTransaction(msbInstance.state, null, config);
 
     if (payload.type === OperationType.TRANSFER) {
         normalizedPayload = normalizeTransferOperation(payload, config);
@@ -66,19 +68,24 @@ export async function broadcastTransaction(msbInstance, config, payload) {
     }
 
     if (!isValid) {
-        throw new Error("Invalid transaction payload.");
+        throw new ValidationError("Invalid transaction payload.");
     }
 
     const success = await msbInstance.broadcastPartialTransaction(payload);
 
     if (!success) {
-        throw new Error("Failed to broadcast transaction after multiple attempts.");
+        throw new BroadcastError("Failed to broadcast transaction after multiple attempts.");
     }
 
     const signedLength = msbInstance.state.getSignedLength();
     const unsignedLength = msbInstance.state.getUnsignedLength();
 
-    return { message: "Transaction broadcasted successfully.", signedLength, unsignedLength, tx: hash };
+    return { 
+        message: "Transaction broadcasted successfully.", 
+        signedLength, 
+        unsignedLength, 
+        tx: hash 
+    };
 }
 
 export async function getTxHashes(msbInstance, start, end) {
@@ -89,7 +96,7 @@ export async function getTxHashes(msbInstance, start, end) {
 export async function getTxDetails(msbInstance, hash) {
     const rawPayload = await get_confirmed_tx_info(msbInstance.state, hash);
     if (!rawPayload) {
-        return null;
+        throw new NotFoundError(`Transaction ${hash} not found.`);
     }
 
     return normalizeDecodedPayloadForJson(rawPayload.decoded, msbInstance.config);
@@ -97,11 +104,11 @@ export async function getTxDetails(msbInstance, hash) {
 
 export async function fetchBulkTxPayloads(msbInstance, hashes) {
     if (!Array.isArray(hashes) || hashes.length === 0) {
-        throw new Error("Missing hash list.");
+        throw new ValidationError("Missing hash list.");
     }
 
     if (hashes.length > 1500) {
-        throw new Error("Length of input tx hashes exceeded.");
+        throw new ValidationError("Length of input tx hashes exceeded.");
     }
 
     const res = { results: [], missing: [] };
@@ -111,7 +118,7 @@ export async function fetchBulkTxPayloads(msbInstance, hashes) {
 
     results.forEach((result, index) => {
         const hash = hashes[index];
-        if (result === null || result === undefined) {
+        if (!result) {
             res.missing.push(hash);
         } else {
             const decodedResult = normalizeDecodedPayloadForJson(result.decoded, msbInstance.config);
@@ -124,32 +131,21 @@ export async function fetchBulkTxPayloads(msbInstance, hashes) {
 
 export async function getExtendedTxDetails(msbInstance, hash, confirmed) {
     const state = msbInstance.state;
+    let rawPayload;
 
     if (confirmed) {
-        const rawPayload = await get_confirmed_tx_info(state, hash);
-        if (!rawPayload) {
-            throw new Error(`No payload found for tx hash: ${hash}`);
-        }
-        const confirmedLength = await state.getTransactionConfirmedLength(hash);
-        if (confirmedLength === null) {
-            throw new Error(`No confirmed length found for tx hash: ${hash} in confirmed mode`);
-        }
-        const normalizedPayload = normalizeDecodedPayloadForJson(rawPayload.decoded, msbInstance.config);
-        const feeBuffer = state.getFee();
-        return {
-            txDetails: normalizedPayload,
-            confirmed_length: confirmedLength,
-            fee: bufferToBigInt(feeBuffer).toString(),
-        };
+        rawPayload = await get_confirmed_tx_info(state, hash);
+    } else {
+        rawPayload = await get_unconfirmed_tx_info(state, hash);
     }
 
-    const rawPayload = await get_unconfirmed_tx_info(state, hash);
     if (!rawPayload) {
-        throw new Error(`No payload found for tx hash: ${hash}`);
+        throw new NotFoundError(`No payload found for tx hash: ${hash}`);
     }
 
     const normalizedPayload = normalizeDecodedPayloadForJson(rawPayload.decoded, msbInstance.config);
     const length = await state.getTransactionConfirmedLength(hash);
+
     if (length === null) {
         return {
             txDetails: normalizedPayload,
@@ -164,4 +160,4 @@ export async function getExtendedTxDetails(msbInstance, hash, confirmed) {
         confirmed_length: length,
         fee: bufferToBigInt(feeBuffer).toString(),
     };
-}
+}