trac-msb 0.1.82 → 0.2.1

package/.github/workflows/CI.yml

@@ -0,0 +1,42 @@
+name: MSB-CI
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+    branches:
+      - '*'
+  workflow_dispatch:
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  tests:
+    runs-on: ${{ matrix.os }}
+
+    strategy:
+      matrix:
+        node-version: [lts/*]
+        os: [ubuntu-latest, macos-latest, windows-latest]
+    steps:
+      - uses: actions/checkout@v4
+      - name: Use Node.js ${{ matrix.node-version }}
+        uses: actions/setup-node@v3
+        with:
+          node-version: ${{ matrix.node-version }}
+          cache: 'npm'
+      - name: Install dependencies
+        run: npm ci
+      - name: Run node tests
+        run: npm run test:node
+      - name: Install bare
+        run: npm i -g bare
+      - name: Run bare tests
+        run: npm run test:bare
+# For now acceptance tests should be disable due to instability of the running MSB instance in the github actions environment
+# Github machines are not powerful enough to run MSB, and we won't ever finish our tests.
+#      - name: Run rpc acceptance tests
+#        run: npm run test:acceptance

package/README.md

@@ -20,9 +20,21 @@ While the MSB supports native node-js, it is encouraged to use Pear:
 cd main_settlement_bus
 npm install -g pear
 npm install
+```
+
+You can run the node in two modes:
+1. Regular node (validator/indexer):
+```js
 pear run . store1
 ```
 
+2. Admin node (access to administrative commands):
+```js
+pear run . admin
+```
+
+The admin mode provides access to additional commands such as `/add_admin`, `/add_whitelist`, `/balance_migration`, `/disable_initialization`, `/add_indexer`, `/remove_indexer`, and `/ban_writer`. These commands are only visible and available when running in admin mode.
+
 **Deploy Bootstrap (admin):**
 
 - Choose option 1)

package/msb.mjs

@@ -1,14 +1,47 @@
 import {MainSettlementBus} from './src/index.js';
 
+const isPear = typeof Pear !== 'undefined';
+const args = isPear ? Pear.config.args : process.argv.slice(2);
+
 const opts = {
-    stores_directory : 'stores3/',
+    stores_directory : 'stores/',
     store_name : typeof process !== "undefined" ? process.argv[2] : Pear.config.args[0],
-    bootstrap: 'a4951e5f744e2a9ceeb875a7965762481dab0a7bb0531a71568e34bf7abd2c53',
-    channel: '0002tracnetworkmainsettlementbus'
+    bootstrap: 'acbc3a4344d3a804101d40e53db1dda82b767646425af73599d4cd6577d69685',
+    channel: '0000trac0network0msb0mainnet0000',
+    enable_role_requester: false,
+    enable_wallet: true,
+    enable_validator_observer: true,
+    enable_interactive_mode: true,
+    disable_rate_limit: false,
+    enable_tx_apply_logs: false,
+    enable_error_apply_logs: false,
 };
 
-const msb = new MainSettlementBus(opts);
+const rpc_opts = {
+    ...opts,
+    enable_tx_apply_logs: false,
+    enable_error_apply_logs: false,
+
+}
+
+const msb = new MainSettlementBus(args.includes('--rpc') ? rpc_opts : opts);
+
+msb.ready().then(async () => {
+    const runRpc = args.includes('--rpc');
+
+    if (runRpc) {
+        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';
+
+        const {startRpcServer} = await import('./rpc/rpc_server.mjs');
+        startRpcServer(msb, host, port);
+    } else {
+        console.log('RPC server will not be started.');
+    }
+
+    msb.interactiveMode();
+});
 
-msb.ready()
-    .then(() => { msb.interactiveMode(); })
-    .catch(function () { });

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "trac-msb",
   "main": "msb.mjs",
-  "version": "0.1.82",
+  "version": "0.2.1",
   "pear": {
     "name": "trac-msb",
     "type": "terminal"
@@ -9,32 +9,57 @@
   "type": "module",
   "scripts": {
     "dev": "pear run -d .",
-    "test:node": "brittle test/all.test.js",
-    "test:bare": "bare test/all.test.js"
+    "prod": "NODE_OPTIONS='--max-old-space-size=4096' pear run . ${npm_config_store}",
+    "dev-rpc": "pear run -d . ${npm_config_store} --rpc --port ${npm_config_port}",
+    "prod-rpc": "pear run . ${npm_config_store} --rpc --host ${npm_config_host} --port ${npm_config_port}",
+    "protobuf": "node scripts/generate-protobufs.js",
+    "test:acceptance": "node --experimental-vm-modules node_modules/jest/bin/jest.js --testTimeout=200000 test/acceptance/",
+    "test:node": "brittle-node -t 1200000 test/all.test.js",
+    "test:bare": "brittle-bare -t 1200000 test/all.test.js",
+    "test:node:cov": "brittle-node -c -t 1200000 test/all.test.js",
+    "test:bare:cov": "brittle-bare -c -t 1200000 test/all.test.js"
   },
   "dependencies": {
-    "autobase": "7.6.3",
-    "hypercore": "11.8.3",
-    "corestore": "7.4.4",
+    "@tracsystems/blake3": "0.0.13",
+    "autobase": "7.20.1",
     "b4a": "1.6.7",
+    "bare-crypto": "1.12.0",
+    "bare-fs": "4.5.0",
+    "bare-http1": "4.1.5",
     "bare-readline": "1.0.7",
     "bare-tty": "5.0.2",
-    "compact-encoding": "^2.16.0",
+    "bech32": "2.0.0",
+    "compact-encoding": "2.18.0",
+    "corestore": "7.5.0",
+    "crypto": "npm:bare-node-crypto",
     "fastest-validator": "1.19.0",
-    "hyperbee": "^2.24.2",
-    "hypercore-crypto": "^3.4.0",
-    "hyperdht": "^6.20.5",
-    "hyperswarm": "^4.11.5",
-    "protomux": "^3.10.1",
+    "http": "npm:bare-node-http",
+    "hyperbee": "2.26.5",
+    "hypercore": "11.18.3",
+    "hypercore-crypto": "3.6.1",
+    "hyperdht": "6.27.0",
+    "hyperswarm": "4.14.2",
+    "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": "0.0.43",
+    "trac-wallet": "0.0.43-msb-r2.8",
     "tty": "npm:bare-node-tty"
   },
+  "devDependencies": {
+    "bare-os": "^3.6.1",
+    "bip39-mnemonic": "^2.4.0",
+    "brittle": "^3.17.1",
+    "esmock": "^2.7.2",
+    "jest": "^30.1.3",
+    "protocol-buffers": "^4.2.0",
+    "sinon": "^21.0.0",
+    "supertest": "^7.1.4",
+    "trac-crypto-api": "^0.1.1"
+  },
   "publishConfig": {
     "registry": "https://registry.npmjs.org",
-    "access": "public",
-    "brittle": "^3.16.2"
+    "access": "public"
   }
 }

package/proto/applyOperations.proto

@@ -0,0 +1,117 @@
+syntax = "proto3";
+
+package apply.operations;
+
+//DO NOT CHANGE THE ORDER AFTER RELEASE - ONLY APPEND NEW ONES
+enum OperationType {
+    UNKNOWN                = 0;
+    ADD_ADMIN              = 1; // complete
+    DISABLE_INITIALIZATION = 2; // complete
+    BALANCE_INITIALIZATION = 3; // complete
+    APPEND_WHITELIST       = 4; // complete
+    ADD_WRITER             = 5; // partial
+    REMOVE_WRITER          = 6; // partial
+    ADMIN_RECOVERY         = 7; // partial
+    ADD_INDEXER            = 8; // complete
+    REMOVE_INDEXER         = 9; // complete
+    BAN_VALIDATOR          = 10; // complete
+    BOOTSTRAP_DEPLOYMENT   = 11; // partial
+    TX                     = 12; // partial
+    TRANSFER               = 13; // partial
+}
+
+// add admin operation, disable_initialization (complete by default)
+message CoreAdminOperation {
+    bytes tx     = 1; // Transaction hash (unique identifier for the transaction)
+    bytes txv    = 2; // Transaction expiration
+    bytes iw     = 3;  // incoming writer key (admin)
+    bytes in     = 4; // Nonce of the invoker (admin)
+    bytes is     = 5; // Signature of the invoker (admin)
+}
+
+// append_whitelist, add_indexer, remove_indexer, ban_writer (complete by default)
+message AdminControlOperation {
+    bytes tx     = 1; // Transaction hash (unique identifier for the transaction)
+    bytes txv    = 2; // Transaction expiration
+    bytes ia     = 3; // selected address to specific operation.
+    bytes in     = 4; // Nonce of the invoker (admin)
+    bytes is     = 5; // Signature of the invoker (admin)
+}
+
+// balance_initialization (complete by default)
+message BalanceInitializationOperation {
+    bytes tx   = 1; // Transaction hash (unique identifier for the transaction)
+    bytes txv  = 2; // Transaction expiration
+    bytes ia   = 3; // selected address to specific operation.
+    bytes am   = 4; // Initial balance to be set for the address
+    bytes in   = 5; // Nonce of the contract invoker (admin)
+    bytes is   = 6; // Signature of the contract invoker (admin)
+}
+// token_transfer (partial - need to be signed by another writer to be complete)
+message TransferOperation {
+    bytes tx      = 1; // Transaction hash (unique identifier for the transaction)
+    bytes txv     = 2; // Transaction expiration
+    bytes to      = 3; // Address of the recipient (any account)
+    bytes am      = 4; // Amount of tokens to transfer
+    bytes in      = 5; // Nonce of the invoker (any account)
+    bytes is      = 6; // Signature of the invoker (any account)
+    bytes va      = 7; // Validator's address (optional)
+    bytes vn      = 8; // Validator's nonce  (optional)
+    bytes vs      = 9; // Validator's signature (optional)
+}
+
+// add_writer, remove_writer, admin_recovery (partial - need to be signed by another writer to be complete)
+message RoleAccessOperation  {
+    bytes tx      = 1;   // Transaction hash (unique identifier for the transaction)
+    bytes txv     = 2;   // Transaction expiration
+    bytes iw      = 3;  // Writing key of the invoker (whitelisted node, admin to be recovered, Trac Network)
+    bytes in      = 4;  // Nonce of the invoker (whitelisted node, admin to be recovered, Trac Network)
+    bytes is      = 5;  // Signature of the invoker (whitelisted node, admin to be recovered)
+    bytes va      = 6; // Validator's address (optional)
+    bytes vn      = 7; // Validator's nonce  (optional)
+    bytes vs      = 8; // Validator's signature (optional)
+}
+
+// transaction - (partial - need to be signed by another writer to be complete)
+message TxOperation {
+    bytes tx   = 1;  // Transaction hash (unique identifier for the transaction)
+    bytes txv  = 2;  // Transaction expiration
+    bytes iw   = 3;  // Writing key of the requesting node (external subnetwork)
+    bytes ch   = 4;  // Content hash (hash of the transaction's data)
+    bytes bs   = 5;  // External bootstrap contract
+    bytes mbs  = 6;  // MSB bootstrap key
+    bytes in   = 7;  // Nonce of the requesting node
+    bytes is   = 8;  // Requester's signature
+    bytes va   = 9;  // Validator's address (optional)
+    bytes vn   = 10; // Validator's nonce  (optional)
+    bytes vs   = 11; // Validator's signature (optional)
+}
+
+// bootstrap deployment - (partial - need to be signed by another writer to be complete)
+message BootstrapDeploymentOperation {
+    bytes tx   = 1; // Transaction hash (unique identifier for the transaction)
+    bytes txv  = 2; // Transaction expiration
+    bytes bs   = 3; // Bootstrap contract address
+    bytes ic   = 4; // Channel on which the contract will operate
+    bytes in   = 5; // Nonce of the contract invoker
+    bytes is   = 6; // Signature of the contract invoker
+    bytes va   = 7; // Validator's address (optional)
+    bytes vn   = 8; // Validator's nonce (optional)
+    bytes vs   = 9; // Validator's signature (optional)
+}
+
+// Main structure for the operations where messages are
+message Operation {
+    OperationType type = 1;
+    bytes address      = 2; // address of the invoker
+
+    oneof value {
+        CoreAdminOperation                cao  = 3;
+        AdminControlOperation             aco  = 4;
+        BalanceInitializationOperation    bio  = 5;
+        TransferOperation                 tro  = 6;
+        RoleAccessOperation               rao  = 7;
+        BootstrapDeploymentOperation      bdo  = 8;
+        TxOperation                       txo  = 9;
+    }
+}

package/rpc/constants.mjs

@@ -0,0 +1 @@
+export const MAX_SIGNED_LENGTH = 1000

package/rpc/cors.mjs

@@ -0,0 +1,15 @@
+export function applyCors(req, res) {
+    // Set CORS headers
+    res.setHeader('Access-Control-Allow-Origin', '*'); // Allow all origins, or specify a domain
+    res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
+    res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
+
+    // Handle preflight OPTIONS request
+    if (req.method === 'OPTIONS') {
+        res.writeHead(204);
+        res.end();
+        return true; // Return true to indicate the request was handled
+    }
+
+    return false; // Return false to indicate the request should be handled by the main router
+}

package/rpc/create_server.mjs

@@ -0,0 +1,72 @@
+// rpc_server.mjs
+import http from 'http'
+import { applyCors } from './cors.mjs';
+import { routes } from './routes/index.mjs';
+
+export const createServer = (msbInstance) => {
+  const server = http.createServer({}, async (req, res) => {
+    
+    // --- 1. Define safe 'respond' utility (Payload MUST be an object) ---
+    const respond = (code, payload) => {
+      // FIX: Prevent attempts to write headers if a response has already started
+      if (res.headersSent) {
+          console.warn(`Attempted to send response (Code: ${code}) after headers were already sent. payload:`, payload);
+          return;
+      }
+      
+      // Enforce JSON content type for all responses
+      res.writeHead(code, { 'Content-Type': 'application/json' });
+      
+      // CRITICAL: Always JSON.stringify the input object
+      res.end(JSON.stringify(payload)); 
+    }
+
+    // --- 2. Catch low-level request stream errors ---
+    req.on('error', (err) => {
+      console.error('Request stream error:', err);
+      // Use the safe respond utility
+      respond(500, { error: 'A stream-level request error occurred.' });
+    });
+
+    if (applyCors(req, res)) return;
+
+    // Find the matching route
+    let foundRoute = false;
+    
+    // Extract the path without query parameters
+    const requestPath = req.url.split('?')[0];
+    
+    // Sort routes by path length (longest first) to ensure more specific routes match first
+    const sortedRoutes = [...routes].sort((a, b) => b.path.length - a.path.length);
+    
+    for (const route of sortedRoutes) {
+        // Exact path matching for base route, allow parameters after base path
+        const routeBase = route.path.endsWith('/') ? route.path.slice(0, -1) : route.path;
+        const requestParts = requestPath.split('/');
+        const routeParts = routeBase.split('/');
+        
+        if (req.method === route.method && 
+            requestParts.length >= routeParts.length &&
+            routeParts.every((part, i) => part === requestParts[i])) {
+            
+            foundRoute = true;
+            try {
+                // This try/catch covers synchronous errors and errors from awaited promises
+                // within the route.handler function.
+                await route.handler({ req, res, respond, msbInstance });
+            } catch (error) {
+                // Catch errors thrown directly from the handler (or its awaited parts)
+                console.error(`Error on ${route.path}:`, error);
+                respond(500, { error: 'An error occurred processing the request.' });
+            }
+            break;
+        }
+    }
+
+    if (!foundRoute) {
+        respond(404, { error: 'Not Found' });
+    }
+  });
+
+  return server
+}

package/rpc/handlers.mjs

@@ -0,0 +1,245 @@
+import { decodeBase64Payload, isBase64, sanitizeBulkPayloadsRequestBody, sanitizeTransferPayload, validatePayloadStructure } from "./utils/helpers.mjs"
+import { MAX_SIGNED_LENGTH } from "./constants.mjs";
+import { isHexString } from "../src/utils/helpers";
+
+export async function handleBalance({ req, respond, msbInstance }) {
+    const [path, queryString] = req.url.split("?");
+    const parts = path.split("/").filter(Boolean);
+    const address = parts[2];
+
+    let confirmed = true; // default
+    if (queryString) {
+        const params = new URLSearchParams(queryString);
+        if (params.has("confirmed")) {
+            confirmed = params.get("confirmed") === "true";
+        }
+    }
+
+    if (!address) {
+        respond(400, { error: 'Wallet address is required' });
+        return;
+    }
+    
+    const commandString =`/get_balance ${address} ${confirmed}`;
+    const nodeInfo = await msbInstance.handleCommand(commandString);
+    const balance = nodeInfo?.balance || 0;
+    respond(200, { address, balance });
+}
+
+export async function handleTxv({ msbInstance, respond }) {
+    const commandString = '/get_txv';
+    const txvRaw = await msbInstance.handleCommand(commandString);
+    const txv = txvRaw.toString('hex');
+    respond(200, { txv });
+}
+
+export async function handleFee({ msbInstance, respond }) {
+    const commandString = '/get_fee';
+    const fee = await msbInstance.handleCommand(commandString);
+    respond(200, { fee });
+}
+
+export async function handleConfirmedLength({ msbInstance, respond }) {
+    const commandString = '/confirmed_length';
+    const confirmed_length = await msbInstance.handleCommand(commandString);
+    respond(200, { confirmed_length });
+}
+
+export async function handleBroadcastTransaction({ msbInstance, respond, req }) {
+    let body = '';
+    req.on('data', chunk => {
+        body += chunk.toString();
+    });
+
+    req.on('end', async () => {
+        try {
+            const { payload } = JSON.parse(body);
+            if (!payload) {
+                return respond(400, { error: 'Payload is missing.' });
+            }
+
+            if (!isBase64(payload)) {
+                return respond(400, { error: 'Payload must be a valid base64 string.' });
+            }
+
+            const decodedPayload = decodeBase64Payload(payload);
+            validatePayloadStructure(decodedPayload);
+            const sanitizedPayload = sanitizeTransferPayload(decodedPayload);
+            const result = await msbInstance.handleCommand('/broadcast_transaction', null, sanitizedPayload);
+            respond(200, { result });
+        } catch (error) {
+            console.error('Error in handleBroadcastTransaction:', error);
+            // Use 400 for client errors (like bad JSON), 500 for server/command errors
+            const code = error instanceof SyntaxError ? 400 : 500;
+            respond(code, { error: code === 400 ? 'Invalid JSON payload.' : 'An error occurred processing the transaction.' });
+        }
+    });
+
+    req.on('error', (err) => {
+        console.error('Stream error in handleBroadcastTransaction:', err);
+        respond(500, { error: 'Request stream failed during body transfer.' });
+    });
+}
+
+export async function handleTxHashes({ msbInstance, respond, req }) {
+    const startSignedLengthStr = req.url.split('/')[3];
+    const endSignedLengthStr = req.url.split('/')[4];
+
+    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.' });
+    }
+
+    if (endSignedLength - startSignedLength > MAX_SIGNED_LENGTH) {
+        return respond(400, { error: `The max range for signedLength must be ${MAX_SIGNED_LENGTH}.` });
+    }
+
+    // 4. Get current confirmed length
+    const currentConfirmedLength = await msbInstance.handleCommand('/confirmed_length');
+
+    // 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 commandString = `/get_txs_hashes ${startSignedLength} ${adjustedEndLength}`;
+    const { hashes } = await msbInstance.handleCommand(commandString);
+    respond(200, { hashes });
+}
+
+export async function handleUnconfirmedLength({ msbInstance, respond }) {
+    const commandString = '/unconfirmed_length';
+    const unconfirmed_length = await msbInstance.handleCommand(commandString);
+    respond(200, { unconfirmed_length });
+}
+
+export async function handleTransactionDetails({ msbInstance, respond, req }) {
+    const hash = req.url.split('/')[3];
+    const commandString = `/get_tx_details ${hash}`;
+    const txDetails = await msbInstance.handleCommand(commandString);
+    respond(txDetails === null ? 404 : 200 , { txDetails });
+}
+
+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
+
+    req.on('data', chunk => {
+        if (headersSent) return; // Stop processing if response has started/errored
+
+        bytesRead += chunk.length;
+        if (bytesRead > limitBytes) { 
+            respond(413, { error: 'Request body too large.' });
+            headersSent = true; 
+            req.destroy(); // Stop receiving data (GOOD PRACTICE)
+            return;
+        }
+        body += chunk.toString();
+    });
+
+    req.on('end', async () => {
+        if (headersSent) return; // Don't process if an error already occurred
+
+
+        try {
+            if (body === null || body === ''){
+                return respond(400, { error: 'Missing payload.' });
+            }
+
+            const sanitizedPayload = sanitizeBulkPayloadsRequestBody(body);
+
+            if (sanitizedPayload === null){
+                return respond(400, { error: '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 msbInstance.handleCommand( `/get_tx_payloads_bulk`, null, uniqueHashes)
+
+            const responseString = JSON.stringify(commandResult);
+            if (Buffer.byteLength(responseString, 'utf8') > 2_000_000) {
+                return respond(413, { error: 'Response too large. Reduce number of hashes.'});
+            }
+
+            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.' });
+        }
+    })
+
+    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 [path, queryString] = req.url.split("?");
+    const pathParts = path.split('/');
+    const hash = pathParts[4];
+    
+    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" });
+    }
+    let confirmed = true; // default
+    if (queryString) {
+        const params = new URLSearchParams(queryString);
+        if (params.has("confirmed")) {
+            const confirmedParam = params.get("confirmed");
+            if (confirmedParam !== "true" && confirmedParam !== "false") {
+                return respond(400, { error: 'Parameter "confirmed" must be exactly "true" or "false"' });
+            }
+            confirmed = confirmedParam === "true";
+        }
+    }
+    
+    try {
+        let txDetails;
+        const commandString = `/get_extended_tx_details ${hash} ${confirmed}`;
+        txDetails = await msbInstance.handleCommand(commandString);
+        if (txDetails === null) {
+            respond(404, { error: `No payload found for tx hash: ${hash}` });
+        } else {
+            respond(200, txDetails);
+        }
+    } 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.' });
+        }
+    }
+}