trac-msb 0.2.17 → 0.2.19

package/cli/interactive.js

@@ -0,0 +1,182 @@
+import ReadyResource from "ready-resource";
+import process from "process";
+import readline from "readline";
+import { WalletProvider, exportWallet, importFromFile } from "trac-wallet";
+import { MainSettlementBus } from "../src/index.js";
+import { sleep } from "../src/utils/helpers.js";
+import fileUtils from "../src/utils/fileUtils.js";
+import { COMMANDS, CommandHandler } from "./commandHandler.js";
+
+class Cli extends ReadyResource {
+    #msb;
+    #config;
+    #commandHandlers;
+    #readlineInstance;
+    #wallet
+
+    constructor(config) {
+        super();
+        this.#config = config;
+    }
+
+    async _open() {
+        this.#readlineInstance = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+            completer: line => this.#completeCommand(line) // This only works without Pear.
+        });
+
+        if (this.#config.enableWallet) {
+            await fileUtils.ensureKeyPathDir(this.#config);
+            await this.#initKeyPair()
+        }
+
+        this.#msb = new MainSettlementBus(this.#config, this.#wallet);
+        await this.#msb.ready();
+    }
+
+    async _close() {
+        if (this.#readlineInstance) {
+            const inputClosed = new Promise((resolve) =>
+                this.#readlineInstance.input.once("close", resolve)
+            );
+            const outputClosed = new Promise((resolve) =>
+                this.#readlineInstance.output.once("close", resolve)
+            );
+
+            this.#readlineInstance.close();
+            this.#readlineInstance.input.destroy();
+            this.#readlineInstance.output.destroy();
+
+            // Do not remove this. Without it, readline may close too quickly and still hang.
+            await Promise.all([inputClosed, outputClosed]).catch((e) =>
+                console.log("Error during closing readline stream:", e)
+            );
+        }
+
+        await sleep(100);
+    }
+
+    startInteractiveMode() {
+        console.log('RPC server will not be started.');
+
+        this.#commandHandlers = new CommandHandler({
+            config: this.#config,
+            msb: this.#msb,
+            handleClose: () => this.close(),
+            wallet: this.#wallet
+        });
+
+        this.#msb.printHelp();
+
+        this.#readlineInstance.on("line", async (input) => {
+            try {
+                await this.#handleCommand(input.trim());
+            } catch (err) {
+                console.error(`${err}`);
+            }
+            this.#readlineInstance.prompt();
+        });
+
+        this.#readlineInstance.prompt();
+    }
+
+    async #handleCommand(input) {
+        return this.#commandHandlers.handle(input);
+    }
+
+    #completeCommand(line) {
+        const commands = Object.values(COMMANDS);
+        const hits = line
+            ? commands.filter(command => command.startsWith(line))
+            : commands;
+
+        return [hits.length ? hits : commands, line];
+    }
+
+    async #initKeyPair() {
+        try {
+            if (fileUtils.verifyWalletPath(this.#config)) {
+                this.#wallet = await importFromFile(this.#config.keyPairPath, undefined, this.#config.addressPrefix)
+            } else {
+                console.log("Key file was not found. How do you wish to proceed?")
+                const wallet = await this.#setupKeypairInteractiveMode()
+                if (!wallet) {
+                    console.error("Invalid response type from keypair setup interactive menu")
+                } else {
+                    this.#wallet = wallet
+                }
+            }
+        } catch (err) {
+            console.error(err);
+        }
+    }
+
+    async #setupKeypairInteractiveMode() {
+        // this would be enable interactive mode (but there is an exception being swallowed so its better to act against the code)
+        if (this.#readlineInstance !== null) {
+            console.log([
+                "[1]. Generate new keypair",
+                "[2]. Restore keypair from 12 or 24-word mnemonic",
+                "Your choice(1/ 2/):"
+            ].join("\n"));
+
+            let choice = await this.#awaitInput()
+
+            try {
+                switch (choice) {
+                    case '1':
+                        const wallet = await new WalletProvider(this.#config).generate({
+                            derivationPath: this.#config.derivationPath
+                        })
+                        console.log([
+                            "This is your mnemonic:",
+                            wallet.mnemonic, 
+                            "Please back it up in a safe location"
+
+                        ].join("\n"))
+                        exportWallet(wallet, this.#config.keyPairPath)
+                        return wallet
+                    case '2':
+                        console.log("Enter your mnemonic phrase:");
+
+                        let mnemonic = await this.#awaitInput()
+                        try {
+                            const wallet = await new WalletProvider(this.#config).fromMnemonic({
+                                mnemonic,
+                                derivationPath: this.#config.derivationPath
+                            })
+                            exportWallet(wallet, this.#config.keyPairPath)
+                            return wallet
+                        } catch {
+                            console.log("Invalid mnemonic. Please check your 12 or 24 words and try again.");
+                            return this.#setupKeypairInteractiveMode();
+                        }
+                    default:
+                        console.log("Invalid choice. Please select again.");
+                        return this.#setupKeypairInteractiveMode();
+                }
+            } catch {
+                console.log("Invalid input. Please try again.");
+                return this.#setupKeypairInteractiveMode();
+            }
+        }
+    }
+
+    async #awaitInput() {
+        let choice = '';
+        const anAction = async input => choice = input
+
+        this.#readlineInstance.on('line', anAction)
+        while ('' === choice) await sleep(1000);
+        this.#readlineInstance.off('line', anAction);
+
+        return choice
+    }
+}
+
+export const startInteractiveMode = async (config) => {
+    const cli = new Cli(config);
+    await cli.ready();
+    cli.startInteractiveMode();
+};

package/msb.mjs

@@ -1,16 +1,15 @@
-import { MainSettlementBus } from './src/index.js';
 import { startRpcServer } from './rpc/rpc_server.js';
+import { startInteractiveMode } from './cli/interactive.js';
 import { isRpcEnabled, resolveConfig } from './src/config/args.js';
 
 const config = resolveConfig()
-const msb = new MainSettlementBus(config);
 
-msb.ready().then(async () => {
+const start = async () => {
     if (isRpcEnabled()) {
-        console.log('Starting RPC server...');
-        startRpcServer(msb, config);
+        await startRpcServer(config)
     } else {
-        console.log('RPC server will not be started.');
-        msb.interactiveMode();
+        await startInteractiveMode(config)
     }
-});
+}
+
+start()

package/package.json

@@ -1,26 +1,39 @@
 {
   "name": "trac-msb",
   "main": "msb.mjs",
-  "version": "0.2.17",
+  "version": "0.2.19",
   "pear": {
     "name": "trac-msb",
     "type": "terminal"
   },
   "type": "module",
+  "files": [
+    "cli/",
+    "msb.mjs",
+    "NOTICE",
+    "rpc/",
+    "SECURITY.md",
+    "scripts/pear-runner.js",
+    "src/"
+  ],
   "scripts": {
-    "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}",
+    "start": "NODE_OPTIONS='--max-old-space-size=4096' node scripts/pear-runner.js",
+    "rpc": "NODE_OPTIONS='--max-old-space-size=4096' node scripts/pear-runner.js --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' node scripts/pear-runner.js --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' node scripts/pear-runner.js --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}",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
     "protobuf": "node scripts/generate-protobufs.js",
+    "docs:check": "node scripts/docs/docs-checker.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",
     "test:unit:node": "brittle-node -t 60000 tests/unit/unit.test.js",
     "test:unit:bare": "brittle-bare -t 60000 tests/unit/unit.test.js",
-    "test:unit:all": "(npm run test:unit:node && npm run test:unit:bare) || exit 1",
-    "test:unit:node:cov": "brittle-node -c -t 60000 tests/unit/unit.test.js",
-    "test:unit:bare:cov": "brittle-bare -c -t 60000  tests/unit/unit.test.js"
+    "test:unit:pear": "BRITTLE='-t 60000' brittle-pear tests/unit/unit.test.js",
+    "test:pear-runner": "node --test tests/runner/pear-runner.test.js",
+    "test:unit:all": "(npm run test:unit:node && npm run test:unit:bare && npm run test:pear-runner) || exit 1",
+    "test:unit:node:cov": "brittle-node -c -t 60000 tests/unit/unit.test.js"
   },
   "dependencies": {
     "autobase": "7.20.1",
@@ -35,6 +48,7 @@
     "compact-encoding": "2.18.0",
     "corestore": "7.5.0",
     "crypto": "npm:bare-node-crypto",
+    "denque": "^2.1.0",
     "fastest-validator": "1.19.0",
     "http": "npm:bare-node-http",
     "hyperbee": "2.26.5",
@@ -42,23 +56,31 @@
     "hypercore-crypto": "3.6.1",
     "hyperdht": "6.27.0",
     "hyperswarm": "4.14.2",
-    "lodash": "^4.17.23",
+    "hyperschema": "1.17.1",
+    "lodash": "^4.18.1",
+    "p-queue": "^9.1.0",
+    "pear-runtime": "1.3.1",
+    "process": "npm:bare-process@4.2.2",
+    "protobufjs": "^7.5.4",
     "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-crypto-api": "0.1.5",
-    "trac-wallet": "1.0.4",
+    "trac-wallet": "2.1.0",
     "tty": "npm:bare-node-tty",
     "uuid": "^13.0.0"
   },
   "devDependencies": {
+    "bare-module": "^6.1.3",
     "bare-os": "^3.6.1",
     "bip39-mnemonic": "^2.4.0",
-    "brittle": "^3.17.1",
+    "brittle": "^3.19.1",
+    "eslint": "^9.39.4",
     "esmock": "^2.7.2",
     "jest": "^30.1.3",
+    "protobufjs-cli": "^1.2.0",
     "protocol-buffers": "^4.2.0",
     "sinon": "^21.0.0",
     "supertest": "^7.1.4"

package/rpc/create_server.js

@@ -4,69 +4,69 @@ import { applyCors } from './cors.js';
 import { routes } from './routes/index.js';
 
 export const createServer = (msbInstance, config) => {
-  const server = http.createServer({}, async (req, res) => {
+    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;
-      }
+        // --- 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' });
+            // 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)); 
-    }
+            // 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.' });
-    });
+        // --- 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;
+        if (applyCors(req, res)) return;
 
-    // Find the matching route
-    let foundRoute = false;
+        // Find the matching route
+        let foundRoute = false;
     
-    // Extract the path without query parameters
-    const requestPath = req.url.split('?')[0];
+        // 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);
+        // 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) {
+        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('/');
+            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 && 
+            if (req.method === route.method && 
             requestParts.length >= routeParts.length &&
             routeParts.every((part, i) => part === requestParts[i])) {
             
-            foundRoute = true;
-            try {
+                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, config});
-            } catch (error) {
+                    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);
-                respond(500, { error: 'An error occurred processing the request.' });
+                    console.error(`Error on ${route.path}:`, error);
+                    respond(500, { error: 'An error occurred processing the request.' });
+                }
+                break;
             }
-            break;
         }
-    }
 
-    if (!foundRoute) {
-        respond(404, { error: 'Not Found' });
-    }
-  });
+        if (!foundRoute) {
+            respond(404, { error: 'Not Found' });
+        }
+    });
 
-  return server
+    return server
 }

package/rpc/handlers.js

@@ -5,35 +5,21 @@ import {
     sanitizeBulkPayloadsRequestBody, 
     sanitizeTransferPayload, 
     validatePayloadStructure,
-    hasSpacesInUrl,
-    BroadcastError, 
-    ValidationError,
-    NotFoundError
+    hasSpacesInUrl
 } from "./utils/helpers.js"
 import { MAX_SIGNED_LENGTH, ZERO_WK } from "./constants.js";
 import { buildRequestUrl } from "./utils/url.js";
-import {
-    getBalance,
-    getTxv,
-    getFee,
-    getConfirmedLength,
-    getUnconfirmedLength,
-    broadcastTransaction,
-    getTxHashes,
-    getTxDetails,
-    fetchBulkTxPayloads,
-    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";
+import { BroadcastError, ValidationError } from "../src/utils/errors.js";
 
 export async function handleHealth({ msbInstance, respond }) {
     try {
-        const isReady = msbInstance && msbInstance.state;
+        const isReady = !!msbInstance?.opened
         if (isReady) return respond(200, { ok: true });
         throw new Error("RPC_OFFLINE");
-    } catch (error) {
+    } catch {
         respond(503, { error: "Could not connect to RPC server" });
     }
 }
@@ -54,28 +40,28 @@ export async function handleBalance({ req, respond, msbInstance }) {
         return;
     }
 
-    const nodeInfo = await getBalance(msbInstance, address, getConfirmedParameter(url) ?? false);
+    const nodeInfo = await msbInstance.getBalance(address, getConfirmedParameter(url, { defaultValue: false }));
     const balance = nodeInfo?.balance || "0";
 
     respond(200, { address, balance });
 }
 
 export async function handleTxv({ msbInstance, respond }) {
-    const txv = await getTxv(msbInstance);
+    const txv = await msbInstance.getTxv();
     respond(200, { txv });
 }
 
 export async function handleFee({ msbInstance, respond }) {
-    const fee = await getFee(msbInstance);
+    const fee = await msbInstance.handleGetFee().toString();
     respond(200, { fee });
 }
 
 export async function handleConfirmedLength({ msbInstance, respond }) {
-    const confirmed_length = await getConfirmedLength(msbInstance);
+    const confirmed_length = await msbInstance.getConfirmedLength();
     respond(200, { confirmed_length });
 }
 
-export async function handleBroadcastTransaction({ msbInstance, config, respond, req }) {
+export async function handleBroadcastTransaction({ msbInstance, respond, req }) {
     let body = '';
     const MAX_BODY_SIZE = 2_000_000;
     let limitExceeded = false;
@@ -101,7 +87,7 @@ export async function handleBroadcastTransaction({ msbInstance, config, respond,
             let parsedBody;
             try {
                 parsedBody = JSON.parse(body);
-            } catch (e) {
+            } catch {
                 throw new ValidationError("Invalid JSON payload.");
             }
 
@@ -118,8 +104,8 @@ export async function handleBroadcastTransaction({ msbInstance, config, respond,
             validatePayloadStructure(decodedPayload);
             const sanitizedPayload = sanitizeTransferPayload(decodedPayload);
 
-            const result = await broadcastTransaction(msbInstance, config, sanitizedPayload);
-            respond(200, { result });
+            const result = await msbInstance.broadcastTransaction(sanitizedPayload);
+            respond(200, { result: { ...result, message: 'Transaction broadcasted successfully.' } });
 
         } catch (error) {
             let code = 500;
@@ -142,7 +128,7 @@ export async function handleBroadcastTransaction({ msbInstance, config, respond,
         }
     });
 
-    req.on('error', (err) => {
+    req.on('error', () => {
         if (!limitExceeded) {
             respond(500, { error: 'Request stream failed during body transfer.' });
         }
@@ -174,15 +160,15 @@ export async function handleTxHashes({ msbInstance, respond, req }) {
         return respond(400, { error: `The max range for signedLength must be ${MAX_SIGNED_LENGTH}.` });
     }
 
-    const currentConfirmedLength = await getConfirmedLength(msbInstance);
+    const currentConfirmedLength = await msbInstance.getConfirmedLength();
     const adjustedEndLength = Math.min(endSignedLength, currentConfirmedLength)
 
-    const { hashes } = await getTxHashes(msbInstance, startSignedLength, adjustedEndLength);
+    const { hashes } = await msbInstance.getTxHashes(startSignedLength, adjustedEndLength);
     respond(200, { hashes });
 }
 
 export async function handleUnconfirmedLength({ msbInstance, respond }) {
-    const unconfirmed_length = await getUnconfirmedLength(msbInstance);
+    const unconfirmed_length = await msbInstance.getUnconfirmedLength();
     respond(200, { unconfirmed_length });
 }
 
@@ -205,18 +191,14 @@ export async function handleTransactionDetails({ msbInstance, respond, req }) {
     }
 
     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;
+        const txDetails = await msbInstance.getTxDetails(normalizedHash);
+        if (!txDetails) {
+            return respond(404, { error: `Transaction ${normalizedHash} not found.` });
         }
 
-        respond(code, { [code === 404 ? 'txDetails' : 'error']: code === 404 ? null : errorMsg });
+        respond(200, { txDetails });
+    } catch {
+        respond(500, { error: "Internal error" });
     }
 }
 
@@ -244,18 +226,14 @@ export async function handleTransactionExtendedDetails({ msbInstance, respond, r
     }
 
     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;
+        const details = await msbInstance.getExtendedTxDetails(hash, confirmed);
+        if (!details) {
+            return respond(404, { error: `No payload found for tx hash: ${hash}` });
         }
 
-        respond(code, { error: errorMsg });
+        respond(200, details);
+    } catch {
+        respond(500, { error: 'An error occurred processing the request.' });
     }
 }
 
@@ -282,17 +260,26 @@ export async function handleFetchBulkTxPayloads({ msbInstance, respond, req }) {
 
         try {
             if (!body) {
-                throw new ValidationError("Missing payload.");
+                return respond(400, { error: "Missing payload." });
             }
 
             const sanitizedPayload = sanitizeBulkPayloadsRequestBody(body);
             if (!sanitizedPayload) {
-                throw new ValidationError("Invalid payload.");
+                return respond(400, { error: "Invalid payload." });
             }
 
             const { hashes } = sanitizedPayload;
+
+            if (!Array.isArray(hashes) || hashes.length === 0) {
+                return respond(400, { error: "Missing hash list." });
+            }
+
             const uniqueHashes = [...new Set(hashes)];
-            const commandResult = await fetchBulkTxPayloads(msbInstance, uniqueHashes);
+
+            if (uniqueHashes.length > 1500) {
+                return respond(400, { error: 'Length of input tx hashes exceeded.' });
+            }
+            const commandResult = await msbInstance.fetchBulkTxPayloads(uniqueHashes);
 
             const responseString = JSON.stringify(commandResult);
             if (Buffer.byteLength(responseString, 'utf8') > 2_000_000) {
@@ -304,7 +291,7 @@ export async function handleFetchBulkTxPayloads({ msbInstance, respond, req }) {
             let code = 500;
             let errorMsg = 'An internal error occurred.';
 
-            if (error instanceof ValidationError || error instanceof SyntaxError) {
+            if (error instanceof SyntaxError) {
                 code = 400;
                 errorMsg = error instanceof SyntaxError ? 'Invalid request body format.' : error.message;
             }
@@ -313,7 +300,7 @@ export async function handleFetchBulkTxPayloads({ msbInstance, respond, req }) {
         }
     })
 
-    req.on('error', (err) => {
+    req.on('error', () => {
         respond(500, { error: 'Request stream failed during body transfer.' });
     });
 }
@@ -365,4 +352,4 @@ export async function handleAccountDetails({ msbInstance, respond, req }) {
         balance: bufferToBigInt(nodeEntry.balance).toString(),
         stakedBalance: bufferToBigInt(nodeEntry.stakedBalance).toString(),
     });
-}
+}

package/rpc/routes/index.js

@@ -5,8 +5,8 @@ import { v1Routes } from './v1.js';
 
 // Map each version to its route list
 const routeMap = {
-  v1: v1Routes,
-  // v2: v2Routes
+    v1: v1Routes,
+    // v2: v2Routes
 };
 
 // Dynamically collect supported versions from routeMap
@@ -14,14 +14,14 @@ const supportedVersions = Object.keys(routeMap);
 
 // Helper to prefix all routes with version
 function prefixRoutes(prefix, routes) {
-  return routes.map(route => ({
-    ...route,
-    path: `/${prefix}${route.path}`,
-  }));
+    return routes.map(route => ({
+        ...route,
+        path: `/${prefix}${route.path}`,
+    }));
 }
 
 // Final route export
 export const routes = [
-  // Prefix each version’s routes automatically
-  ...supportedVersions.flatMap(v => prefixRoutes(v, routeMap[v])),
+    // Prefix each version’s routes automatically
+    ...supportedVersions.flatMap(v => prefixRoutes(v, routeMap[v])),
 ];