trac-msb 0.2.8 → 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 msb = new MainSettlementBus(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, 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.8",
+  "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,13 +42,15 @@
     "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": "0.0.43-msb-r2.9",
-    "tty": "npm:bare-node-tty"
+    "trac-wallet": "1.0.2",
+    "tty": "npm:bare-node-tty",
+    "uuid": "^13.0.0"
   },
   "devDependencies": {
     "bare-os": "^3.6.1",
@@ -66,5 +66,9 @@
   "publishConfig": {
     "registry": "https://registry.npmjs.org",
     "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Trac-Systems/main_settlement_bus"
   }
 }

package/proto/network.proto

@@ -0,0 +1,74 @@
+syntax = "proto3";
+
+package network.v1;
+
+enum MessageType {
+    MESSAGE_TYPE_UNSPECIFIED = 0;
+    MESSAGE_TYPE_VALIDATOR_CONNECTION_REQUEST = 1;
+    MESSAGE_TYPE_VALIDATOR_CONNECTION_RESPONSE = 2;
+    MESSAGE_TYPE_LIVENESS_REQUEST = 3;
+    MESSAGE_TYPE_LIVENESS_RESPONSE = 4;
+    MESSAGE_TYPE_BROADCAST_TRANSACTION_REQUEST = 5;
+    MESSAGE_TYPE_BROADCAST_TRANSACTION_RESPONSE = 6;
+}
+
+enum ResultCode {
+    RESULT_CODE_UNSPECIFIED = 0;
+    RESULT_CODE_OK = 1;
+    RESULT_CODE_INVALID_PAYLOAD = 2;
+    RESULT_CODE_UNSUPPORTED_VERSION = 3;
+    RESULT_CODE_RATE_LIMITED = 4;
+    RESULT_CODE_TIMEOUT = 5;
+    RESULT_CODE_SIGNATURE_INVALID = 6;
+}
+
+message ValidatorConnectionRequest {
+    string issuer_address = 1;
+    bytes nonce = 2;
+    bytes signature = 3;
+}
+
+message ValidatorConnectionResponse {
+    string issuer_address = 1;
+    bytes nonce = 2;
+    bytes signature = 3;
+    ResultCode result = 4;
+}
+
+message LivenessRequest {
+    bytes nonce = 1;
+    bytes signature = 2;
+}
+
+message LivenessResponse {
+    bytes nonce = 1;
+    bytes signature = 2;
+    ResultCode result = 3;
+}
+
+message BroadcastTransactionRequest {
+    bytes data = 1; // binary encoded payload
+    bytes nonce = 2;
+    bytes signature = 3;
+}
+
+message BroadcastTransactionResponse {
+    bytes nonce = 1;
+    bytes signature = 2;
+    ResultCode result = 3;
+}
+
+message MessageHeader {
+    MessageType type = 1;
+    string id = 2;
+    uint64 timestamp = 3;
+    oneof field {
+        ValidatorConnectionRequest            validator_connection_request  = 4;
+        ValidatorConnectionResponse           validator_connection_response  = 5;
+        LivenessRequest                       liveness_request = 6;
+        LivenessResponse                      liveness_response = 7;
+        BroadcastTransactionRequest           broadcast_transaction_request = 8;
+        BroadcastTransactionResponse          broadcast_transaction_response = 9;
+    }
+    repeated string capabilities = 10;
+}

package/rpc/create_server.js

@@ -3,7 +3,7 @@ import http from 'http'
 import { applyCors } from './cors.js';
 import { routes } from './routes/index.js';
 
-export const createServer = (msbInstance) => {
+export const createServer = (msbInstance, config) => {
   const server = http.createServer({}, async (req, res) => {
     
     // --- 1. Define safe 'respond' utility (Payload MUST be an object) ---
@@ -53,7 +53,7 @@ export const createServer = (msbInstance) => {
             try {
                 // This try/catch covers synchronous errors and errors from awaited promises
                 // within the route.handler function.
-                await route.handler({ req, res, respond, msbInstance });
+                await route.handler({ req, res, respond,  msbInstance, config});
             } catch (error) {
                 // Catch errors thrown directly from the handler (or its awaited parts)
                 console.error(`Error on ${route.path}:`, error);

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 });
 }
 
@@ -52,46 +75,77 @@ export async function handleConfirmedLength({ msbInstance, respond }) {
     respond(200, { confirmed_length });
 }
 
-export async function handleBroadcastTransaction({ msbInstance, respond, req }) {
+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, sanitizedPayload);
+
+            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, host, port) {
-    const server = createServer(msbInstance)
+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}`);
     });
 }