trac-msb 0.2.9 → 0.2.11

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,24 @@ 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 { sleep } from "../src/utils/helpers.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";
+import PartialTransactionValidator from "../src/core/network/protocols/shared/validators/PartialTransactionValidator.js";
+import PartialTransferValidator from "../src/core/network/protocols/shared/validators/PartialTransferValidator.js";
+
+// This was added because V1 is not waiting for signed/unsigned state. So to include reverse compatibility
+// we need to slow down v1 to legacy case.
+const waitForUnconfirmedTx = async (state, txHash, config) => {
+    const startedAt = Date.now();
+    while ((Date.now() - startedAt) < config.messageValidatorResponseTimeout) {
+        const payload = await state.get(txHash);
+        if (payload) return true;
+        await sleep(100);
+    }
+    return false;
+};
 
 export async function getBalance(msbInstance, address, confirmed) {
     const state = msbInstance.state;
@@ -46,14 +60,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 PartialTransferValidator(msbInstance.state, null , config);
+    const partialTransactionValidator = new PartialTransactionValidator(msbInstance.state, null , config);
 
     if (payload.type === OperationType.TRANSFER) {
         normalizedPayload = normalizeTransferOperation(payload, config);
@@ -66,19 +81,29 @@ 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 isConfirmed = await waitForUnconfirmedTx(msbInstance.state, hash, config);
+    if (!isConfirmed) {
+        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 +114,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 +122,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 +136,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 +149,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 +178,4 @@ export async function getExtendedTxDetails(msbInstance, hash, confirmed) {
         confirmed_length: length,
         fee: bufferToBigInt(feeBuffer).toString(),
     };
-}
+}

package/rpc/utils/helpers.js

@@ -1,74 +1,105 @@
 import b4a from "b4a"
 import { operationToPayload } from "../../src/utils/applyOperations.js"
+import { isHexString } from "../../src/utils/helpers.js"; 
+
+export class ValidationError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ValidationError";
+  }
+}
+
+export class BroadcastError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "BroadcastError";
+  }
+}
+
+export class NotFoundError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "NotFoundError";
+  }
+}
+
 export function decodeBase64Payload(base64) {
-	let decodedPayloadString
-	try {
-		decodedPayloadString = b4a.from(base64, "base64").toString("utf-8")
-	} catch (err) {
-		throw new Error("Failed to decode base64 payload.")
-	}
-
-	try {
-		return JSON.parse(decodedPayloadString)
-	} catch (err) {
-		throw new Error("Decoded payload is not valid JSON.")
-	}
+  let decodedPayloadString
+  try {
+    decodedPayloadString = b4a.from(base64, "base64").toString("utf-8")
+  } catch (err) {
+    throw new ValidationError("Failed to decode base64 payload.")
+  }
+
+  try {
+    return JSON.parse(decodedPayloadString)
+  } catch (err) {
+    throw new ValidationError("Decoded payload is not valid JSON.")
+  }
 }
 
 export function isBase64(str) {
-	const base64Regex =
-		/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/
-	return base64Regex.test(str)
+  const base64Regex =
+    /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/
+  return base64Regex.test(str)
 }
 
 export function validatePayloadStructure(payload) {
-	if (
-		typeof payload !== "object" ||
-		payload === null ||
-		typeof payload.type !== "number" ||
-		typeof payload.address !== "string" ||
-		!["txo", "tro"].some((key) => key in payload && typeof payload[key] === "object")
-	) {
-		throw new Error("Invalid payload structure.")
-	}
+  if (
+    typeof payload !== "object" ||
+    payload === null ||
+    typeof payload.type !== "number" ||
+    typeof payload.address !== "string" ||
+    !["txo", "tro"].some((key) => key in payload && typeof payload[key] === "object")
+  ) {
+    throw new ValidationError("Invalid payload structure.")
+  }
 }
 
 export function sanitizeTransferPayload(payload) {
-	const operationKey = operationToPayload(payload.type);
+  const operationKey = operationToPayload(payload.type);
 
-	if (operationKey !== 'tro' && operationKey !== 'txo') {
-		throw new Error('Payload is not a transfer/transaction operation.');
-	}
+  if (operationKey !== 'tro' && operationKey !== 'txo') {
+    throw new ValidationError('Payload is not a transfer/transaction operation.');
+  }
 
-	const operation = payload[operationKey];
-	if (payload.address && typeof payload.address === "string") {
-		payload.address = payload.address.trim()
-	}
+  const operation = payload[operationKey];
+  if (payload.address && typeof payload.address === "string") {
+    payload.address = payload.address.trim()
+  }
 
-	if (operation && typeof operation === "object") {
-		for (const [key, value] of Object.entries(operation)) {
-			if (typeof value === "string") {
-				let sanitized = value.trim()
+  if (operation && typeof operation === "object") {
+    for (const [key, value] of Object.entries(operation)) {
+      if (typeof value === "string") {
+        let sanitized = value.trim()
 
-				// normalize hex-like strings
-				if (/^[0-9A-F]+$/i.test(sanitized)) {
-					sanitized = sanitized.toLowerCase()
-				}
+        // normalize hex-like strings
+        if (/^[0-9A-F]+$/i.test(sanitized)) {
+          sanitized = sanitized.toLowerCase()
+        }
 
-				payload[operationKey][key] = sanitized
-			}
-		}
-	}
+        payload[operationKey][key] = sanitized
+      }
+    }
+  }
 
-	return payload
+  return payload
 }
 
 export function sanitizeBulkPayloadsRequestBody(body) {
-	const cleanBody = body
-		.replace(/^\uFEFF/, '')
-		.replace(/\r/g, '')
-		.replace(/\0/g, '')
-		.trim();
+  const cleanBody = body
+    .replace(/^\uFEFF/, '')
+    .replace(/\r/g, '')
+    .replace(/\0/g, '')
+    .trim();
 
-	return JSON.parse(cleanBody);
+  return JSON.parse(cleanBody);
 }
+
+export function isValidTxHash(hash) {
+    return isHexString(hash) && hash?.length === 64;
+}
+
+export function hasSpacesInUrl(url) {
+    return url.includes('%20') || url.includes(' ');
+}

package/scripts/generate-protobufs.js

@@ -2,10 +2,10 @@ import fs from 'fs';
 import path from 'path';
 
 import { fileURLToPath } from 'url';
-import { execSync } from 'child_process';
+import { execFileSync } from 'child_process';
 
 function generateCJSFromProto(inputPath, outputPath) {
-    execSync(`protocol-buffers "${inputPath}" -o "${outputPath}"`);
+    execFileSync('protocol-buffers', [inputPath, '-o', outputPath]);
     console.log(`${outputPath} has been generated.`);
 }
 
@@ -17,26 +17,51 @@ function transformToUseB4a(outputPath) {
     console.log(`${outputPath} has been modified to use b4a.`);
 }
 
+function generatePbjsModule(pbjsPath, protoRootPath, entryPath, outputPath) {
+    execFileSync(pbjsPath, [
+        '-t', 'static-module',
+        '-w', 'commonjs',
+        '--keep-case',
+        '-p', protoRootPath,
+        '-o', outputPath,
+        entryPath
+    ]);
+    console.log(`${outputPath} has been generated.`);
+}
+
+function transformPbjsForBare(outputPath) {
+    let content = fs.readFileSync(outputPath, 'utf-8');
+    const shim = `if (typeof globalThis !== 'undefined' && typeof globalThis.self === 'undefined') {\n  globalThis.self = globalThis;\n}\n`;
+    const strictDirective = '"use strict";';
+
+    if (content.includes(strictDirective)) {
+        content = content.replace(strictDirective, `${strictDirective}\n${shim}`);
+    } else {
+        content = `${strictDirective}\n${shim}${content}`;
+    }
+
+    fs.writeFileSync(outputPath, content, 'utf-8');
+    console.log(`${outputPath} has been modified for bare-compatible protobufjs runtime.`);
+}
 
 function main() {
     const directoryName = path.dirname(fileURLToPath(import.meta.url));
 
     const inputDir = path.join(directoryName, '../proto');
     const outputDir = path.join(directoryName, '../src/utils/protobuf');
+    const pbjsPath = path.join(directoryName, '../node_modules/.bin/pbjs');
+    const applyInputPath = path.join(inputDir, 'applyOperations.proto');
+    const applyOutputPath = path.join(outputDir, 'applyOperations.cjs');
+    const networkEntryPath = path.join(inputDir, 'network/v1/network_message.proto');
+    const generatedNetworkOutputPath = path.join(outputDir, 'networkV1.generated.cjs');
 
     fs.mkdirSync(outputDir, { recursive: true });
 
-    const files = fs.readdirSync(inputDir).filter(f => f.endsWith('.proto'));
+    generateCJSFromProto(applyInputPath, applyOutputPath);
+    transformToUseB4a(applyOutputPath);
 
-    for (const file of files) {
-        const name = path.basename(file, '.proto');
-        const inputPath = path.join(inputDir, file);
-        const outputPath = path.join(outputDir, `${name}.cjs`);
-
-        generateCJSFromProto(inputPath, outputPath);
-        transformToUseB4a(outputPath);
-    }
+    generatePbjsModule(pbjsPath, inputDir, networkEntryPath, generatedNetworkOutputPath);
+    transformPbjsForBare(generatedNetworkOutputPath);
 }
 
 main();
-

package/src/config/args.js

@@ -0,0 +1,46 @@
+import { createConfig, ENV } from './env.js';
+
+const getArguments = () => {
+    const pearApp = typeof Pear !== 'undefined' ? (Pear.app ?? Pear.config) : undefined;
+    const runtimeArgs = typeof process !== 'undefined' ? process.argv.slice(2) : [];
+    return pearApp?.args ?? runtimeArgs;
+};
+
+export const resolveEnvironment = (args = []) => {
+    const networkIndex = args.indexOf('--network');
+    const network = (networkIndex !== -1 && args[networkIndex + 1]) ? args[networkIndex + 1] : undefined;
+
+    if (network === ENV.MAINNET) return ENV.MAINNET;
+    if (network === ENV.DEVELOPMENT) return ENV.DEVELOPMENT;
+    if (network === ENV.TESTNET1 || network === 'testnet') return ENV.TESTNET1;
+    return ENV.MAINNET;
+};
+
+export const isRpcEnabled = () => {
+    const args = getArguments();
+    return args.includes('--rpc');
+};
+
+export const resolveConfig = () => {
+    const args = getArguments();
+    const runRpc = isRpcEnabled();
+    const selectedEnv = resolveEnvironment(args);
+    const storesDirectoryIndex = args.indexOf('--stores-directory');
+    const storesDirectory = (storesDirectoryIndex !== -1 && args[storesDirectoryIndex + 1]) ? args[storesDirectoryIndex + 1] : undefined;
+    const hostIndex = args.indexOf('--host');
+    const host = (hostIndex !== -1 && args[hostIndex + 1]) ? args[hostIndex + 1] : undefined;
+    const portIndex = args.indexOf('--port');
+    const port = (portIndex !== -1 && args[portIndex + 1]) ? parseInt(args[portIndex + 1], 10) : undefined;
+
+    const rpc = {
+        storesDirectory,
+        enableWallet: false,
+        enableInteractiveMode: false,
+        host,
+        port
+    };
+
+    const options = runRpc ? rpc : { storesDirectory };
+
+    return createConfig(selectedEnv, options);
+};

package/src/config/config.js

@@ -1,4 +1,6 @@
 import b4a from 'b4a'
+import { isDefined } from '../utils/type.js'
+import _ from 'lodash'
 
 export class Config {
     #options
@@ -80,7 +82,7 @@ export class Config {
     }
 
     get isAdminMode() {
-        return this.#options.storeName === 'admin'
+        return _.endsWith(this.storesDirectory, '/admin')
     }
 
     get keyPairPath()  {
@@ -97,17 +99,68 @@ export class Config {
         return this.#config.maxValidators
     }
 
+    get maxPeers() {
+        if (this.#isOverriden('maxPeers')) return this.#options.maxPeers
+        return this.#config.maxPeers
+    }
+
+    get maxParallel() {
+        if (this.#isOverriden('maxParallel')) return this.#options.maxParallel
+        return this.#config.maxParallel
+    }
+
+    get maxServerConnections() {
+        if (this.#isOverriden('maxServerConnections')) return this.#options.maxServerConnections
+        return this.#config.maxServerConnections
+    }
+
+    get maxClientConnections() {
+        if (this.#isOverriden('maxClientConnections')) return this.#options.maxClientConnections
+        return this.#config.maxClientConnections
+    }
+
+    get maxWritersForAdminIndexerConnection() {
+        if (this.#isOverriden('maxWritersForAdminIndexerConnection')) return this.#options.maxWritersForAdminIndexerConnection
+        return this.#config.maxWritersForAdminIndexerConnection
+    }
+
+    get processIntervalMs() {
+        if (this.#isOverriden('processIntervalMs')) return this.#options.processIntervalMs
+        return this.#config.processIntervalMs
+    }
+
+    get transactionPoolSize() {
+        if (this.#isOverriden('transactionPoolSize')) return this.#options.transactionPoolSize
+        return this.#config.transactionPoolSize
+    }
+
     get networkId() {
         return this.#config.networkId
     }
 
+    get host() {
+        if (this.#isOverriden('host')) return this.#options.host
+        return this.#config.host
+    }
+
+    get port() {
+        if (this.#isOverriden('port')) return this.#options.port
+        return this.#config.port
+    }
+
     get storesDirectory() {
-        if (this.#isOverriden('storesDirectory')) return this.#options.storesDirectory
-        return this.#config.storesDirectory
+        const storesDirectory = this.#isOverriden('storesDirectory') ?
+            this.#options.storesDirectory : this.#config.storesDirectory
+
+        return _.trimEnd(storesDirectory, '/')
+    }
+
+    get storeName() {
+        return this.#config.storeName
     }
 
     get storesFullPath() {
-        return `${this.storesDirectory}${this.#options.storeName}`
+        return `${this.storesDirectory}/${this.storeName}`
     }
 
     get messageThreshold() {
@@ -122,9 +175,49 @@ export class Config {
         return this.#config.messageValidatorResponseTimeout
     }
 
+    get rateLimitCleanupIntervalMs() {
+        if (this.#isOverriden('rateLimitCleanupIntervalMs')) return this.#options.rateLimitCleanupIntervalMs
+        return this.#config.rateLimitCleanupIntervalMs
+    }
+
+    get rateLimitConnectionTimeoutMs() {
+        if (this.#isOverriden('rateLimitConnectionTimeoutMs')) return this.#options.rateLimitConnectionTimeoutMs
+        return this.#config.rateLimitConnectionTimeoutMs
+    }
+
+    get rateLimitMaxTransactionsPerSecond() {
+        if (this.#isOverriden('rateLimitMaxTransactionsPerSecond')) return this.#options.rateLimitMaxTransactionsPerSecond
+        return this.#config.rateLimitMaxTransactionsPerSecond
+    }
+    
+    get pendingRequestTimeout() {
+        return this.#config.pendingRequestTimeout
+    }
+
+    get txCommitTimeout() {
+        return this.#config.txCommitTimeout
+    }
+
+    get txPoolSize() {
+        return this.#config.txPoolSize
+    }
+
+    get validatorHealthCheckInterval() {
+        if (this.#isOverriden('validatorHealthCheckInterval')) return this.#options.validatorHealthCheckInterval
+        return this.#config.validatorHealthCheckInterval
+    }
+
+    get maxPendingRequestsInPendingRequestsService() {
+        return this.#config.maxPendingRequestsInPendingRequestsService
+    }
+
+    get debug() {
+        return this.#config.debug
+    }
+
     // Most of these properties are boolean
     #isOverriden(prop) {
-        return this.#options.hasOwnProperty(prop)
+        return this.#options.hasOwnProperty(prop) && isDefined(this.#options[prop])
     }
 
     #validate(options, config) {
@@ -134,4 +227,5 @@ export class Config {
             );
         }
     }
+
 }