trac-msb 0.2.5 → 0.2.6

package/msb.mjs

@@ -1,12 +1,13 @@
-import {MainSettlementBus} from './src/index.js';
+import { MainSettlementBus } from './src/index.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 opts = {
-    stores_directory : 'stores/',
-    store_name : pearApp?.args?.[0] ?? runtimeArgs[0],
+    stores_directory: 'stores/',
+    store_name: pearApp?.args?.[0] ?? runtimeArgs[0],
     bootstrap: 'acbc3a4344d3a804101d40e53db1dda82b767646425af73599d4cd6577d69685',
     channel: '0000trac0network0msb0mainnet0000',
     enable_role_requester: false,
@@ -23,15 +24,12 @@ const rpc_opts = {
     enable_tx_apply_logs: false,
     enable_error_apply_logs: false,
     enable_wallet: false,
-    enable_interactive_mode: true,
-
-}
+    enable_interactive_mode: false,
+};
 
-const msb = new MainSettlementBus(args.includes('--rpc') ? rpc_opts : opts);
+const msb = new MainSettlementBus(runRpc ? rpc_opts : opts);
 
 msb.ready().then(async () => {
-    const runRpc = args.includes('--rpc');
-
     if (runRpc) {
         console.log('Starting RPC server...');
         const portIndex = args.indexOf('--port');
@@ -42,8 +40,6 @@ msb.ready().then(async () => {
         const {startRpcServer} = await import('./rpc/rpc_server.mjs');
         startRpcServer(msb, host, port);
     } else {
-        console.log('RPC server will not be started.');
+        msb.interactiveMode();
     }
-
-    msb.interactiveMode();
 });

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "trac-msb",
   "main": "msb.mjs",
-  "version": "0.2.5",
+  "version": "0.2.6",
   "pear": {
     "name": "trac-msb",
     "type": "terminal"

package/rpc/handlers.mjs

@@ -2,6 +2,18 @@ import { decodeBase64Payload, isBase64, sanitizeBulkPayloadsRequestBody, sanitiz
 import { MAX_SIGNED_LENGTH, ZERO_WK } from "./constants.mjs";
 import { buildRequestUrl } from "./utils/url.mjs";
 import { isHexString } from "../src/utils/helpers.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.mjs";
@@ -20,28 +32,23 @@ export async function handleBalance({ req, respond, msbInstance }) {
         return;
     }
 
-    const commandString = `/get_balance ${address} ${confirmed}`;
-    const nodeInfo = await msbInstance.handleCommand(commandString);
+    const nodeInfo = await getBalance(msbInstance, address, confirmed);
     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');
+    const txv = await getTxv(msbInstance);
     respond(200, { txv });
 }
 
 export async function handleFee({ msbInstance, respond }) {
-    const commandString = '/get_fee';
-    const fee = await msbInstance.handleCommand(commandString);
+    const fee = await getFee(msbInstance);
     respond(200, { fee });
 }
 
 export async function handleConfirmedLength({ msbInstance, respond }) {
-    const commandString = '/confirmed_length';
-    const confirmed_length = await msbInstance.handleCommand(commandString);
+    const confirmed_length = await getConfirmedLength(msbInstance);
     respond(200, { confirmed_length });
 }
 
@@ -65,7 +72,7 @@ export async function handleBroadcastTransaction({ msbInstance, respond, req })
             const decodedPayload = decodeBase64Payload(payload);
             validatePayloadStructure(decodedPayload);
             const sanitizedPayload = sanitizeTransferPayload(decodedPayload);
-            const result = await msbInstance.handleCommand('/broadcast_transaction', null, sanitizedPayload);
+            const result = await broadcastTransaction(msbInstance, sanitizedPayload);
             respond(200, { result });
         } catch (error) {
             let code = error instanceof SyntaxError ? 400 : 500;
@@ -118,33 +125,25 @@ export async function handleTxHashes({ msbInstance, respond, req }) {
     }
 
     // 4. Get current confirmed length
-    const currentConfirmedLength = await msbInstance.handleCommand('/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 commandString = `/get_txs_hashes ${startSignedLength} ${adjustedEndLength}`;
-    const { hashes } = await msbInstance.handleCommand(commandString);
+    const { hashes } = await getTxHashes(msbInstance, startSignedLength, adjustedEndLength);
     respond(200, { hashes });
 }
 
 export async function handleUnconfirmedLength({ msbInstance, respond }) {
-    // TODO: VALIDATION? 
-    const commandString = '/unconfirmed_length';
-    const unconfirmed_length = await msbInstance.handleCommand(commandString);
+    const unconfirmed_length = await getUnconfirmedLength(msbInstance);
     respond(200, { unconfirmed_length });
 }
 
 export async function handleTransactionDetails({ msbInstance, respond, req }) {
-    // TODO: VALIDATION? 
-    const url = buildRequestUrl(req);
-    const pathParts = url.pathname.split('/').filter(Boolean);
-    const hash = pathParts[2];
-
-    const commandString = `/get_tx_details ${hash}`;
-    const txDetails = await msbInstance.handleCommand(commandString);
-    respond(txDetails === null ? 404 : 200, { txDetails });
+    const hash = req.url.split('/')[3];
+    const txDetails = await getTxDetails(msbInstance, hash);
+    respond(txDetails === null ? 404 : 200 , { txDetails });
 }
 
 export async function handleFetchBulkTxPayloads({ msbInstance, respond, req }) {
@@ -193,7 +192,7 @@ export async function handleFetchBulkTxPayloads({ msbInstance, respond, req }) {
 
             const uniqueHashes = [...new Set(hashes)];
 
-            const commandResult = await msbInstance.handleCommand(`/get_tx_payloads_bulk`, null, uniqueHashes)
+            const commandResult = await fetchBulkTxPayloads(msbInstance, uniqueHashes);
 
             const responseString = JSON.stringify(commandResult);
             if (Buffer.byteLength(responseString, 'utf8') > 2_000_000) {
@@ -234,14 +233,8 @@ export async function handleTransactionExtendedDetails({ msbInstance, respond, r
     }
 
     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);
-        }
+        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 });

package/rpc/rpc_services.js

@@ -0,0 +1,126 @@
+import { bufferToBigInt } from "../src/utils/amountSerialization.js";
+import { normalizeDecodedPayloadForJson } from "../src/utils/normalizers.js";
+import { get_confirmed_tx_info, get_unconfirmed_tx_info } from "../src/utils/cli.js";
+
+export async function getBalance(msbInstance, address, confirmed) {
+    const state = msbInstance.state;
+    const useUnconfirmed = confirmed === false;
+
+    const nodeEntry = useUnconfirmed
+        ? await state.getNodeEntryUnsigned(address)
+        : await state.getNodeEntry(address);
+
+    if (!nodeEntry) return undefined;
+
+    return {
+        address,
+        balance: bufferToBigInt(nodeEntry.balance).toString(),
+    };
+}
+
+export async function getTxv(msbInstance) {
+    const txv = await msbInstance.state.getIndexerSequenceState();
+    return txv.toString("hex");
+}
+
+export async function getFee(msbInstance) {
+    const feeBuffer = msbInstance.state.getFee();
+    return bufferToBigInt(feeBuffer).toString();
+}
+
+export async function getConfirmedLength(msbInstance) {
+    return msbInstance.state.getSignedLength();
+}
+
+export async function getUnconfirmedLength(msbInstance) {
+    return msbInstance.state.getUnsignedLength();
+}
+
+export async function broadcastTransaction(msbInstance, payload) {
+    return msbInstance.broadcastTransactionCommand(payload);
+}
+
+export async function getTxHashes(msbInstance, start, end) {
+    const hashes = await msbInstance.state.confirmedTransactionsBetween(start, end);
+    return { hashes };
+}
+
+export async function getTxDetails(msbInstance, hash) {
+    const rawPayload = await get_confirmed_tx_info(msbInstance.state, hash);
+    if (!rawPayload) {
+        return null;
+    }
+
+    return normalizeDecodedPayloadForJson(rawPayload.decoded);
+}
+
+export async function fetchBulkTxPayloads(msbInstance, hashes) {
+    if (!Array.isArray(hashes) || hashes.length === 0) {
+        throw new Error("Missing hash list.");
+    }
+
+    if (hashes.length > 1500) {
+        throw new Error("Length of input tx hashes exceeded.");
+    }
+
+    const res = { results: [], missing: [] };
+
+    const promises = hashes.map((hash) => get_confirmed_tx_info(msbInstance.state, hash));
+    const results = await Promise.all(promises);
+
+    results.forEach((result, index) => {
+        const hash = hashes[index];
+        if (result === null || result === undefined) {
+            res.missing.push(hash);
+        } else {
+            const decodedResult = normalizeDecodedPayloadForJson(result.decoded);
+            res.results.push({ hash, payload: decodedResult });
+        }
+    });
+
+    return res;
+}
+
+export async function getExtendedTxDetails(msbInstance, hash, confirmed) {
+    const state = msbInstance.state;
+
+    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, true);
+        const feeBuffer = state.getFee();
+        return {
+            txDetails: normalizedPayload,
+            confirmed_length: confirmedLength,
+            fee: bufferToBigInt(feeBuffer).toString(),
+        };
+    }
+
+    const rawPayload = await get_unconfirmed_tx_info(state, hash);
+    if (!rawPayload) {
+        throw new Error(`No payload found for tx hash: ${hash}`);
+    }
+
+    const normalizedPayload = normalizeDecodedPayloadForJson(rawPayload.decoded, true);
+    const length = await state.getTransactionConfirmedLength(hash);
+    if (length === null) {
+        return {
+            txDetails: normalizedPayload,
+            confirmed_length: 0,
+            fee: "0",
+        };
+    }
+
+    const feeBuffer = state.getFee();
+    return {
+        txDetails: normalizedPayload,
+        confirmed_length: length,
+        fee: bufferToBigInt(feeBuffer).toString(),
+    };
+}