trac-msb 0.2.8 → 0.2.10

package/rpc/rpc_services.js

@@ -1,6 +1,15 @@
 import { bufferToBigInt } from "../src/utils/amountSerialization.js";
-import { normalizeDecodedPayloadForJson } from "../src/utils/normalizers.js";
+import {
+    normalizeDecodedPayloadForJson,
+    normalizeTransactionOperation,
+    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 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";
 
 export async function getBalance(msbInstance, address, confirmed) {
     const state = msbInstance.state;
@@ -36,8 +45,47 @@ export async function getUnconfirmedLength(msbInstance) {
     return msbInstance.state.getUnsignedLength();
 }
 
-export async function broadcastTransaction(msbInstance, payload) {
-    return msbInstance.broadcastTransactionCommand(payload);
+export async function broadcastTransaction(msbInstance, config, payload) {
+    if (!payload) {
+        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);
+
+    if (payload.type === OperationType.TRANSFER) {
+        normalizedPayload = normalizeTransferOperation(payload, config);
+        isValid = await partialTransferValidator.validate(normalizedPayload);
+        hash = b4a.toString(normalizedPayload.tro.tx, "hex");
+    } else if (payload.type === OperationType.TX) {
+        normalizedPayload = normalizeTransactionOperation(payload, config);
+        isValid = await partialTransactionValidator.validate(normalizedPayload);
+        hash = b4a.toString(normalizedPayload.txo.tx, "hex");
+    }
+
+    if (!isValid) {
+        throw new ValidationError("Invalid transaction payload.");
+    }
+
+    const success = await msbInstance.broadcastPartialTransaction(payload);
+
+    if (!success) {
+        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 
+    };
 }
 
 export async function getTxHashes(msbInstance, start, end) {
@@ -48,7 +96,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);
@@ -56,11 +104,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: [] };
@@ -70,7 +118,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);
@@ -83,32 +131,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,
@@ -123,4 +160,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/operations.js"
+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/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,73 @@ 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 maxPartialTxPayloadByteSize() {
+        if (this.#isOverriden('maxPartialTxPayloadByteSize')) return this.#options.maxPartialTxPayloadByteSize
+        return this.#config.maxPartialTxPayloadByteSize
+    }
+
+    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 +180,24 @@ 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
+    }
+
     // 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) {

package/src/config/env.js

@@ -1,13 +1,52 @@
-import { TRAC_NETWORK_MSB_MAINNET_PREFIX } from 'trac-wallet/constants.js';
+import { TRAC_NETWORK_MSB_MAINNET_PREFIX, TRAC_NETWORK_MSB_TESTNET1_PREFIX } from 'trac-wallet/constants.js';
 import { Config } from './config.js';
+import { TRAC_NETWORK_TESTNET_ID, TRAC_NETWORK_MAINNET_ID } from 'trac-crypto-api/constants.js';
 
 export const ENV = {
     MAINNET: 'mainnet',
     DEVELOPMENT: 'development',
     TESTNET1: 'testnet1'
 }
+// TODO: CREATE TEST ENV CONFIG SIMILAR TO MAINNET AND USE IT IN TESTS.
 
 const configData = {
+    [ENV.TESTNET1]: {
+        addressLength: 67,
+        addressPrefix: TRAC_NETWORK_MSB_TESTNET1_PREFIX,
+        addressPrefixLength: TRAC_NETWORK_MSB_TESTNET1_PREFIX.length,
+        bech32mHrpLength: TRAC_NETWORK_MSB_TESTNET1_PREFIX.length + 1, // len(addressPrefix + separator)
+        bootstrap: 'a7c0c2cf8e4722129097f89b2a29a092f23d6268fcca3fd9570ba5b702b99b95',
+        channel: '1111trac1network1msb1testnet1111',
+        dhtBootstrap: ['116.202.214.149:10001', '157.180.12.214:10001', 'node1.hyperdht.org:49737', 'node2.hyperdht.org:49737', 'node3.hyperdht.org:49737'], // these are used to peer discovery
+        disableRateLimit: false,
+        enableErrorApplyLogs: true,
+        enableInteractiveMode: true,
+        enableRoleRequester: false,
+        enableTxApplyLogs: true,
+        enableValidatorObserver: true,
+        enableWallet: true,
+        maxValidators: 6,
+        maxRetries: 1,
+        messageThreshold: 1000,
+        messageValidatorRetryDelay: 1000, //How long to wait before retrying (ms) MESSAGE_VALIDATOR_RETRY_DELAY_MS
+        messageValidatorResponseTimeout: 3 * 3 * 1000, //Overall timeout for sending a message (ms). This is 3 * maxRetries * messageValidatorRetryDelay;
+        host: 'localhost',
+        port: 5000,
+        networkId: TRAC_NETWORK_TESTNET_ID,
+        maxPeers: 64, // Connectivity constants
+        maxParallel: 64, // Connectivity constants
+        maxServerConnections: Infinity, // Connectivity constants
+        maxClientConnections: Infinity, // Connectivity constants
+        maxWritersForAdminIndexerConnection: 10, // Connectivity constants
+        processIntervalMs: 50, // Pool constants
+        maxPartialTxPayloadByteSize: 3072, // Operation handler constants
+        transactionPoolSize: 1000, // Operation handler constants
+        rateLimitCleanupIntervalMs: 120_000, // Rate limiting constants
+        rateLimitConnectionTimeoutMs: 60_000, // Rate limiting constants
+        rateLimitMaxTransactionsPerSecond: 50, // Rate limiting constants
+        storesDirectory : 'stores/',
+        storeName: 'testnet',
+    },
     [ENV.MAINNET]: {
         addressLength: 63,
         addressPrefix: TRAC_NETWORK_MSB_MAINNET_PREFIX,
@@ -28,8 +67,22 @@ const configData = {
         messageThreshold: 3,
         messageValidatorRetryDelay: 1000, //How long to wait before retrying (ms) MESSAGE_VALIDATOR_RETRY_DELAY_MS
         messageValidatorResponseTimeout: 3 * 3 * 1000, //Overall timeout for sending a message (ms). This is 3 * maxRetries * messageValidatorRetryDelay;
-        networkId: 918,
+        host: 'localhost',
+        port: 5000,
+        networkId: TRAC_NETWORK_MAINNET_ID,
+        maxPeers: 64, // Connectivity constants
+        maxParallel: 64, // Connectivity constants
+        maxServerConnections: Infinity, // Connectivity constants
+        maxClientConnections: Infinity, // Connectivity constants
+        maxWritersForAdminIndexerConnection: 10, // Connectivity constants
+        processIntervalMs: 50, // Pool constants
+        maxPartialTxPayloadByteSize: 3072, // Operation handler constants
+        transactionPoolSize: 1000, // Operation handler constants
+        rateLimitCleanupIntervalMs: 120_000, // Rate limiting constants
+        rateLimitConnectionTimeoutMs: 60_000, // Rate limiting constants
+        rateLimitMaxTransactionsPerSecond: 50, // Rate limiting constants
         storesDirectory: 'stores/',
+        storeName: 'mainnet',
     },
     [ENV.DEVELOPMENT]: {
         addressLength: 63,
@@ -51,8 +104,22 @@ const configData = {
         messageThreshold: 1000,
         messageValidatorRetryDelay: 1000, //How long to wait before retrying (ms) MESSAGE_VALIDATOR_RETRY_DELAY_MS
         messageValidatorResponseTimeout: 3 * 3 * 1000, //Overall timeout for sending a message (ms). This is 3 * maxRetries * messageValidatorRetryDelay;
-        networkId: 918,
+        host: 'localhost',
+        port: 5000,
+        networkId: TRAC_NETWORK_TESTNET_ID,
+        maxPeers: 64, // Connectivity constants
+        maxParallel: 64, // Connectivity constants
+        maxServerConnections: Infinity, // Connectivity constants
+        maxClientConnections: Infinity, // Connectivity constants
+        maxWritersForAdminIndexerConnection: 10, // Connectivity constants
+        processIntervalMs: 50, // Pool constants
+        maxPartialTxPayloadByteSize: 3072, // Operation handler constants
+        transactionPoolSize: 1000, // Operation handler constants
+        rateLimitCleanupIntervalMs: 120_000, // Rate limiting constants
+        rateLimitConnectionTimeoutMs: 60_000, // Rate limiting constants
+        rateLimitMaxTransactionsPerSecond: 50, // Rate limiting constants
         storesDirectory : 'stores/',
+        storeName: 'development',
     }
 }