trac-msb 0.2.6 → 0.2.8

package/src/messages/partialStateMessages/PartialStateMessageOperations.js

@@ -2,6 +2,17 @@ import PartialStateMessageBuilder from './PartialStateMessageBuilder.js';
 import PartialStateMessageDirector from './PartialStateMessageDirector.js';
 
 class PartialStateMessageOperations {
+    #wallet;
+    #config
+
+    /**
+     * @param {PeerWallet} wallet - Wallet of the requester/invoker node that broadcasts the operation
+     * @param {object} config - A configuration object
+     */
+    constructor(wallet, config) {
+        this.#wallet = wallet;
+        this.#config = config;
+    }
 
     /**
      * Assembles a PARTIAL bootstrap deployment operation, which can be sent to a validator.
@@ -9,8 +20,6 @@ class PartialStateMessageOperations {
      * Bootstrap deployment is required to register a subnetwork. The network will reject
      * TransactionOperation messages for external bootstraps that are not registered.
      * Do NOT attempt to register the MSB bootstrap key.
-     *
-     * @param {Object} wallet - Wallet of the requester/invoker node that broadcasts the operation
      * @param {String} externalBootstrap - Bootstrap key from the subnetwork to be registered.
      *                                    MUST be different from the MSB bootstrap key.
      *                                    BEFORE deploying ensure if the subnetwork bootstrap is not already deployed.
@@ -20,13 +29,13 @@ class PartialStateMessageOperations {
      * @returns {Promise<Object>} The assembled bootstrap deployment operation message
      * @throws {Error} If assembly of the bootstrap deployment operation message fails
      */
-    static async assembleBootstrapDeploymentMessage(wallet, externalBootstrap, channel, txValidity) {
+    async assembleBootstrapDeploymentMessage(externalBootstrap, channel, txValidity) {
         try {
-            const builder = new PartialStateMessageBuilder(wallet);
+            const builder = new PartialStateMessageBuilder(this.#wallet, this.#config);
             const director = new PartialStateMessageDirector();
             director.builder = builder;
             return await director.buildPartialBootstrapDeploymentMessage(
-                wallet.address,
+                this.#wallet.address,
                 externalBootstrap,
                 channel,
                 txValidity
@@ -36,34 +45,34 @@ class PartialStateMessageOperations {
         }
     }
 
-    static async assembleAddWriterMessage(wallet, writingKey, txValidity) {
+    async assembleAddWriterMessage(writingKey, txValidity) {
         try {
-            const builder = new PartialStateMessageBuilder(wallet);
+            const builder = new PartialStateMessageBuilder(this.#wallet, this.#config);
             const director = new PartialStateMessageDirector();
             director.builder = builder;
-            return await director.buildAddWriterMessage(wallet.address, writingKey, txValidity);
+            return await director.buildAddWriterMessage(this.#wallet.address, writingKey, txValidity);
         } catch (error) {
             throw new Error(`Failed to assemble add writer message: ${error.message}`);
         }
     }
 
-    static async assembleRemoveWriterMessage(wallet, writerKey, txValidity) {
+    async assembleRemoveWriterMessage(writerKey, txValidity) {
         try {
-            const builder = new PartialStateMessageBuilder(wallet);
+            const builder = new PartialStateMessageBuilder(this.#wallet, this.#config);
             const director = new PartialStateMessageDirector();
             director.builder = builder;
-            return await director.buildRemoveWriterMessage(wallet.address, writerKey, txValidity);
+            return await director.buildRemoveWriterMessage(this.#wallet.address, writerKey, txValidity);
         } catch (error) {
             throw new Error(`Failed to assemble remove writer message: ${error.message}`);
         }
     }
 
-    static async assembleAdminRecoveryMessage(wallet, writingKey, txValidity) {
+    async assembleAdminRecoveryMessage(writingKey, txValidity) {
         try {
-            const builder = new PartialStateMessageBuilder(wallet);
+            const builder = new PartialStateMessageBuilder(this.#wallet, this.#config);
             const director = new PartialStateMessageDirector();
             director.builder = builder;
-            return await director.buildAdminRecoveryMessage(wallet.address, writingKey, txValidity);
+            return await director.buildAdminRecoveryMessage(this.#wallet.address, writingKey, txValidity);
         } catch (error) {
             throw new Error(`Failed to assemble admin recovery message: ${error.message}`);
         }
@@ -73,8 +82,6 @@ class PartialStateMessageOperations {
     /**
      * Assembles a PARTIAL transaction operation, which can be sent to a validator, who can then
      * sign the transaction to make it COMPLETE.
-     *
-     * @param {Object} wallet - Wallet of the requester/invoker node that broadcasts the transaction
      * @param {String} incomingWritingKey - Writing key from the subnetwork, used for authentication of the requesting node
      * @param {String} txValidity - Transaction validity hash representing current indexer combination.
      *                              Transaction remains valid as long as indexer keys maintain their order.
@@ -91,13 +98,13 @@ class PartialStateMessageOperations {
      * @returns {Promise<Object>} The assembled transaction operation message
      * @throws {Error} If assembly of the transaction operation message fails
      */
-    static async assembleTransactionOperationMessage(wallet, incomingWritingKey, txValidity, contentHash, externalBootstrap, msbBootstrap) {
+    async assembleTransactionOperationMessage(incomingWritingKey, txValidity, contentHash, externalBootstrap, msbBootstrap) {
         try {
-            const builder = new PartialStateMessageBuilder(wallet);
+            const builder = new PartialStateMessageBuilder(this.#wallet, this.#config);
             const director = new PartialStateMessageDirector();
             director.builder = builder;
             return await director.buildTransactionOperationMessage(
-                wallet.address,
+                this.#wallet.address,
                 incomingWritingKey,
                 txValidity,
                 contentHash,
@@ -109,13 +116,13 @@ class PartialStateMessageOperations {
         }
     }
 
-    static async assembleTransferOperationMessage(wallet, recipientAddress, amount, txValidity) {
+    async assembleTransferOperationMessage(recipientAddress, amount, txValidity) {
         try {
-            const builder = new PartialStateMessageBuilder(wallet);
+            const builder = new PartialStateMessageBuilder(this.#wallet, this.#config);
             const director = new PartialStateMessageDirector();
             director.builder = builder;
             return await director.buildTransferOperationMessage(
-                wallet.address,
+                this.#wallet.address,
                 recipientAddress,
                 amount,
                 txValidity

package/src/utils/check.js

@@ -10,9 +10,7 @@ import {
     BOOTSTRAP_BYTE_LENGTH,
     CHANNEL_BYTE_LENGTH,
     AMOUNT_BYTE_LENGTH,
-    TRAC_ADDRESS_SIZE,
 } from './constants.js';
-
 //TODO: ATTENTION - CURRENT IMPLEMENTATION UTILIZES `custom` FOR MULTIPLE TIMES IN MANY SCHEMAS. IT SHOULD BE CLEANED UP
 // TO UTILIZE ONLY ONE FUNCTION COMMON FOR ALL THE SCHEMAS. CREATE A TICKED P2/P3.
 
@@ -25,8 +23,13 @@ class Check {
     #validateTransactionOperationSchema
     #validateTransferOperationSchema
     #validateBalanceInitializationSchema
+    #config
 
-    constructor() {
+    /**
+     * @param {object} config
+     **/
+    constructor(config) {
+        this.#config = config
 
         this.#validator = new Validator({
             useNewCustomCheckerFunction: true,
@@ -101,6 +104,7 @@ class Check {
 
     // Complete by default - no writer needed
     #compileCoreAdminOperationSchema() {
+        const addressLength = this.#config.addressLength
         const schema = {
             $$strict: true,
             type: {
@@ -124,7 +128,7 @@ class Check {
                     return value;
                 }
             },
-            address: { type: 'buffer', length: TRAC_ADDRESS_SIZE, required: true }, // invoker adddress (admin)
+            address: {type: 'buffer', length: addressLength, required: true}, // invoker adddress (admin)
             cao: {
                 strict: true,
                 type: 'object',
@@ -163,14 +167,14 @@ class Check {
                     return value;
                 }
             },
-            address: { type: 'buffer', length: TRAC_ADDRESS_SIZE, required: true },
+            address: { type: 'buffer', length: this.#config.addressLength, required: true },
             bio: {
                 strict: true,
                 type: 'object',
                 props: {
                     tx: { type: 'buffer', length: HASH_BYTE_LENGTH, required: true }, // tx hash
                     txv: { type: 'buffer', length: HASH_BYTE_LENGTH, required: true }, // tx validity
-                    ia: { type: 'buffer', length: TRAC_ADDRESS_SIZE, required: true }, // selected address to specific operation.
+                    ia: { type: 'buffer', length: this.#config.addressLength, required: true }, // selected address to specific operation.
                     am: { type: 'buffer', length: AMOUNT_BYTE_LENGTH, required: true }, // amount to transfer
                     in: { type: 'buffer', length: NONCE_BYTE_LENGTH, required: true }, // nonce of the invoker
                     is: { type: 'buffer', length: SIGNATURE_BYTE_LENGTH, required: true }, // signature of the invoker
@@ -211,14 +215,14 @@ class Check {
                     return value;
                 }
             },
-            address: { type: 'buffer', length: TRAC_ADDRESS_SIZE, required: true }, // invoker adddress (admin)
+            address: {type: 'buffer', length: this.#config.addressLength, required: true}, // invoker adddress (admin)
             aco: {
                 strict: true,
                 type: 'object',
                 props: {
                     tx: { type: 'buffer', length: HASH_BYTE_LENGTH, required: true }, // tx hash
                     txv: { type: 'buffer', length: HASH_BYTE_LENGTH, required: true }, // tx validity
-                    ia: { type: 'buffer', length: TRAC_ADDRESS_SIZE, required: true }, // incoming address - selected address for specific operation
+                    ia: { type: 'buffer', length: this.#config.addressLength, required: true }, // incoming address - selected address for specific operation
                     in: { type: 'buffer', length: NONCE_BYTE_LENGTH, required: true }, // nonce
                     is: { type: 'buffer', length: SIGNATURE_BYTE_LENGTH, required: true }, // signature
                 }
@@ -256,7 +260,7 @@ class Check {
                     return value;
                 }
             },
-            address: { type: 'buffer', length: TRAC_ADDRESS_SIZE, required: true },
+            address: {type: 'buffer', length: this.#config.addressLength, required: true},
             rao: {
                 strict: true,
                 type: 'object',
@@ -266,7 +270,7 @@ class Check {
                     iw: { type: 'buffer', length: WRITER_BYTE_LENGTH, required: true }, // writing key of the invoker
                     in: { type: 'buffer', length: NONCE_BYTE_LENGTH, required: true }, // nonce of the invoker
                     is: { type: 'buffer', length: SIGNATURE_BYTE_LENGTH, required: true }, // signature
-                    va: { type: 'buffer', length: TRAC_ADDRESS_SIZE, optional: true },
+                    va: { type: 'buffer', length: this.#config.addressLength, optional: true },
                     vn: { type: 'buffer', length: NONCE_BYTE_LENGTH, optional: true },
                     vs: { type: 'buffer', length: SIGNATURE_BYTE_LENGTH, optional: true }
 
@@ -325,7 +329,7 @@ class Check {
                     return value;
                 }
             },
-            address: { type: 'buffer', length: TRAC_ADDRESS_SIZE, required: true }, // invoker address
+            address: {type: 'buffer', length: this.#config.addressLength, required: true}, // invoker address
             txo: {
                 strict: true,
                 type: 'object',
@@ -338,7 +342,7 @@ class Check {
                     mbs: { type: 'buffer', length: BOOTSTRAP_BYTE_LENGTH, required: true }, // MSB bootstrap key
                     in: { type: 'buffer', length: NONCE_BYTE_LENGTH, required: true }, // Nonce of the requesting node
                     is: { type: 'buffer', length: SIGNATURE_BYTE_LENGTH, required: true }, // Requester's signature
-                    va: { type: 'buffer', length: TRAC_ADDRESS_SIZE, optional: true }, //validator address
+                    va: { type: 'buffer', length: this.#config.addressLength, optional: true }, //validator address
                     vn: { type: 'buffer', length: NONCE_BYTE_LENGTH, optional: true }, //validator nonce
                     vs: { type: 'buffer', length: SIGNATURE_BYTE_LENGTH, optional: true }, //validator signature
                 },
@@ -396,7 +400,7 @@ class Check {
                     return value;
                 }
             },
-            address: { type: 'buffer', length: TRAC_ADDRESS_SIZE, required: true },
+            address: {type: 'buffer', length: this.#config.addressLength, required: true},
             bdo: {
 
                 strict: true,
@@ -408,7 +412,7 @@ class Check {
                     ic: { type: 'buffer', length: CHANNEL_BYTE_LENGTH, required: true },
                     in: { type: 'buffer', length: NONCE_BYTE_LENGTH, required: true },
                     is: { type: 'buffer', length: SIGNATURE_BYTE_LENGTH, required: true },
-                    va: { type: 'buffer', length: TRAC_ADDRESS_SIZE, optional: true },
+                    va: { type: 'buffer', length: this.#config.addressLength, optional: true },
                     vn: { type: 'buffer', length: NONCE_BYTE_LENGTH, optional: true },
                     vs: { type: 'buffer', length: SIGNATURE_BYTE_LENGTH, optional: true },
                 },
@@ -466,18 +470,18 @@ class Check {
                     return value;
                 }
             },
-            address: { type: 'buffer', length: TRAC_ADDRESS_SIZE, required: true },
+            address: {type: 'buffer', length: this.#config.addressLength, required: true},
             tro: {
                 strict: true,
                 type: 'object',
                 props: {
                     tx: { type: 'buffer', length: HASH_BYTE_LENGTH, required: true }, // tx hash
                     txv: { type: 'buffer', length: HASH_BYTE_LENGTH, required: true }, // tx validity
-                    to: { type: 'buffer', length: TRAC_ADDRESS_SIZE, required: true }, // recipient address
+                    to: { type: 'buffer', length: this.#config.addressLength, required: true }, // recipient address
                     am: { type: 'buffer_amount', length: AMOUNT_BYTE_LENGTH, required: true }, // amount to transfer
                     in: { type: 'buffer', length: NONCE_BYTE_LENGTH, required: true }, // nonce of the invoker
                     is: { type: 'buffer', length: SIGNATURE_BYTE_LENGTH, required: true }, // signature of the invoker
-                    va: { type: 'buffer', length: TRAC_ADDRESS_SIZE, optional: true },  // validator address
+                    va: { type: 'buffer', length: this.#config.addressLength, optional: true },  // validator address
                     vn: { type: 'buffer', length: NONCE_BYTE_LENGTH, optional: true },  // validator nonce
                     vs: { type: 'buffer', length: SIGNATURE_BYTE_LENGTH, optional: true } // validator signature
 

package/src/utils/cliCommands.js

@@ -83,20 +83,20 @@ export async function coreInfoCommand(state) {
     }
 }
 
-export async function getValidatorAddressCommand(state, wkHexString) {
+export async function getValidatorAddressCommand(state, wkHexString, prefix) {
     const payload = await state.getSigned(EntryType.WRITER_ADDRESS + wkHexString);
     if (payload === null) {
         console.log(`No address assigned to the writer key: ${wkHexString}`);
     } else {
-        console.log(`Address assigned to the writer key: ${wkHexString} - ${bufferToAddress(payload)}`);
+        console.log(`Address assigned to the writer key: ${wkHexString} - ${bufferToAddress(payload, prefix)}`);
     }
 }
 
-export async function getDeploymentCommand(state, bootstrapHex) {
+export async function getDeploymentCommand(state, bootstrapHex, addressLength) {
     const deploymentEntry = await state.getRegisteredBootstrapEntry(bootstrapHex);
     console.log(`Searching deployment for bootstrap: ${bootstrapHex}`);
     if (deploymentEntry) {
-        const decodedDeploymentEntry = deploymentEntryUtils.decode(deploymentEntry);
+        const decodedDeploymentEntry = deploymentEntryUtils.decode(deploymentEntry, addressLength);
         const txhash = decodedDeploymentEntry.txHash.toString("hex");
         console.log(`Bootstrap deployed under transaction hash: ${txhash}`);
         const payload = await state.getSigned(txhash);
@@ -189,7 +189,7 @@ export function getUnconfirmedLengthCommand(state) {
     return unconfirmedLength;
 }
 
-export async function getTxPayloadsBulkCommand(state, hashes) {
+export async function getTxPayloadsBulkCommand(state, hashes, config) {
     if (!Array.isArray(hashes) || hashes.length === 0) {
         throw new Error("Missing hash list.");
     }
@@ -208,7 +208,7 @@ export async function getTxPayloadsBulkCommand(state, hashes) {
         if (result === null || result === undefined) {
             res.missing.push(hash);
         } else {
-            const decodedResult = normalizeDecodedPayloadForJson(result.decoded);
+            const decodedResult = normalizeDecodedPayloadForJson(result.decoded, config);
             res.results.push({ hash, payload: decodedResult });
         }
     });
@@ -225,20 +225,20 @@ export async function getTxHashesCommand(state, start, end) {
     }
 }
 
-export async function getTxDetailsCommand(state, hash) {
+export async function getTxDetailsCommand(state, hash, config) {
     try {
         const rawPayload = await get_confirmed_tx_info(state, hash);
         if (!rawPayload) {
             console.log(`No payload found for tx hash: ${hash}`);
             return null;
         }
-        return normalizeDecodedPayloadForJson(rawPayload.decoded);
+        return normalizeDecodedPayloadForJson(rawPayload.decoded, config);
     } catch (error) {
         throw new Error("Invalid params to perform the request.", error.message);
     }
 }
 
-export async function getExtendedTxDetailsCommand(state, hash, confirmed) {
+export async function getExtendedTxDetailsCommand(state, hash, confirmed, config) {
     if (confirmed) {
         const rawPayload = await get_confirmed_tx_info(state, hash);
         if (!rawPayload) {
@@ -248,7 +248,7 @@ export async function getExtendedTxDetailsCommand(state, hash, confirmed) {
         if (confirmedLength === null) {
             throw new Error(`No confirmed length found for tx hash: ${hash} in confirmed mode`);
         }
-        const normalizedPayload = normalizeDecodedPayloadForJson(rawPayload.decoded, true);
+        const normalizedPayload = normalizeDecodedPayloadForJson(rawPayload.decoded, config);
         const fee = state.getFee();
         return {
             txDetails: normalizedPayload,
@@ -261,7 +261,7 @@ export async function getExtendedTxDetailsCommand(state, hash, confirmed) {
     if (!rawPayload) {
         throw new Error(`No payload found for tx hash: ${hash}`);
     }
-    const normalizedPayload = normalizeDecodedPayloadForJson(rawPayload.decoded, true);
+    const normalizedPayload = normalizeDecodedPayloadForJson(rawPayload.decoded, config);
     const length = await state.getTransactionConfirmedLength(hash);
     if (length === null) {
         return {

package/src/utils/constants.js

@@ -40,6 +40,8 @@ export const EventType = Object.freeze({
     WRITABLE: 'writable',
     UNWRITABLE: 'unwritable',
     WARNING: 'warning',
+    VALIDATOR_CONNECTION_READY: 'validator-connection-ready',
+    VALIDATOR_CONNECTION_TIMEOUT: 'validator-connection-timeout',
 });
 
 // Role managment constants
@@ -66,7 +68,6 @@ export const MAX_PEERS = 64;
 export const MAX_PARALLEL = 64;
 export const MAX_SERVER_CONNECTIONS = Infinity;
 export const MAX_CLIENT_CONNECTIONS = Infinity;
-export const DHT_BOOTSTRAPS = ['116.202.214.149:10001', '157.180.12.214:10001', 'node1.hyperdht.org:49737', 'node2.hyperdht.org:49737', 'node3.hyperdht.org:49737'];
 export const MAX_WRITERS_FOR_ADMIN_INDEXER_CONNECTION = 10;
 // State
 export const ACK_INTERVAL = 1_000;
@@ -119,11 +120,3 @@ export const NETWORK_MESSAGE_TYPES = Object.freeze({
         NODE: 'nodeResponse'
     },
 });
-
-export const TRAC_ADDRESS_SIZE =  63; // TODO: Change this to config().addressLength || 63
-export const NETWORK_ID = 918; // TODO: Change this to config().network_id || 918
-
-export const MAX_VALIDATORS = 50
-export const MAX_RETRIES = 3
-
-export const MAX_REQUEST_COUNT = 5;

package/src/utils/fileUtils.js

@@ -1,11 +1,8 @@
 import fs from 'fs'; // TODO: If we are using bare environment, we should use bare-fs instead
 import path from 'path';
 import { WHITELIST_FILEPATH, BALANCE_MIGRATION_FILEPATH, BALANCE_MIGRATED_DIR, WHITELIST_MIGRATION_DIR } from '../utils/constants.js';
-import { isAddressValid } from '../core/state/utils/address.js';
 import { decimalStringToBigInt, bigIntTo16ByteBuffer, bufferToBigInt, bigIntToDecimalString } from './amountSerialization.js';
-import PeerWallet from 'trac-wallet';
-import b4a from 'b4a';
-import { ZERO_LICENSE } from '../core/state/utils/nodeEntry.js';
+
 const MIGRATED_FILE_REGEX = /^migrated(\d+)\.csv$/;
 
 /**

package/src/utils/helpers.js

@@ -1,6 +1,6 @@
 import b4a from "b4a";
 import {bufferToAddress} from "../core/state/utils/address.js";
-import { EntryType, TRAC_ADDRESS_SIZE } from "./constants.js";
+import { EntryType } from "./constants.js";
 
 //TODO: change file name or split functions below into multiple files (Remember to update imports and tests accordingly)
 
@@ -48,7 +48,7 @@ export const safeJsonParse = (str) => {
     return undefined;
 }
 
-export async function getFormattedIndexersWithAddresses(state) {
+export async function getFormattedIndexersWithAddresses(state, config) {
     const indexers = await state.getIndexersEntry();
     const formatted = indexers.map((entry) => ({
         writingKey: b4a.toString(entry.key, "hex"),
@@ -56,7 +56,10 @@ export async function getFormattedIndexersWithAddresses(state) {
 
     const results = await Promise.all(
         formatted.map(async (entry) => {            
-            const address = bufferToAddress(await state.getSigned(EntryType.WRITER_ADDRESS + entry.writingKey));
+            const address = bufferToAddress(
+                await state.getSigned(EntryType.WRITER_ADDRESS + entry.writingKey),
+                config.addressPrefix
+            );
 
             return {
                 ...entry,
@@ -68,14 +71,14 @@ export async function getFormattedIndexersWithAddresses(state) {
     return results;
 }
 
-export function formatIndexersEntry(indexersEntry) {
+export function formatIndexersEntry(indexersEntry, addressLength) {
 
     const count = indexersEntry[0];
     const indexers = [];
 
     for (let i = 0; i < count; i++) {
-        const start = 1 + (i * TRAC_ADDRESS_SIZE);
-        const end = start + TRAC_ADDRESS_SIZE;
+        const start = 1 + (i * addressLength);
+        const end = start + addressLength;
         const indexerAddr = indexersEntry.subarray(start, end);
         indexers.push(indexerAddr.toString('ascii'));
     }
@@ -86,20 +89,6 @@ export function formatIndexersEntry(indexersEntry) {
     };
 }
 
-export function convertAdminCoreOperationPayloadToHex(payload) {
-    return {
-        ...payload,
-        address: bufferToAddress(payload.address),
-        aco: {
-            tx: payload.aco.tx.toString('hex'),
-            txv: payload.aco.txv.toString('hex'),
-            in: payload.aco.in.toString('hex'),
-            ia: payload.aco.ia.toString('hex'),
-            is: payload.aco.is.toString('hex'),
-        },
-    };
-}
-
 export function isTransactionRecordPut(entry) {
     const isPut = entry.type === "put";
     const isHex = isHexString(entry.key);

package/src/utils/migrationUtils.js

@@ -4,8 +4,8 @@ import PeerWallet from 'trac-wallet';
 import b4a from 'b4a';
 import { ZERO_LICENSE } from '../core/state/utils/nodeEntry.js';
 
-export async function validateAddressFromIncomingFile(stateInstance, address, adminEntry) {
-    if (!isAddressValid(address)) {
+export async function validateAddressFromIncomingFile(stateInstance, config, address, adminEntry) {
+    if (!isAddressValid(address, config.addressPrefix)) {
         throw new Error(`Invalid address format: '${address}'. Please ensure all addresses are valid.`);
     }
 

package/src/utils/normalizers.js

@@ -10,10 +10,11 @@ import { bufferToBigInt } from './amountSerialization.js'
  * to the correct buffer or hexadecimal string format for processing.
  *
  * @param {Object} payload The raw payload for the transfer operation.
+ * @param {object} config The environment configuration object.
  * @returns {Object} A new object with addresses converted to buffers and hex values normalized.
  * @throws {Error} If the payload is invalid or missing required fields.
  */
-export function normalizeTransferOperation(payload) {
+export function normalizeTransferOperation(payload, config) {
     if (!payload || typeof payload !== 'object' || !payload.tro) {
         throw new Error('Invalid payload for transfer operation normalization.');
     }
@@ -31,19 +32,19 @@ export function normalizeTransferOperation(payload) {
         tx: normalizeHex(tro.tx),     // Transaction hash
         txv: normalizeHex(tro.txv),   // Transaction validity
         in: normalizeHex(tro.in),     // Nonce
-        to: addressToBuffer(tro.to),   // Recipient address
+        to: addressToBuffer(tro.to, config.addressPrefix),   // Recipient address
         am: normalizeHex(tro.am),     // Amount
         is: normalizeHex(tro.is)      // Signature
     };
 
     return {
         type,
-        address: addressToBuffer(address),
+        address: addressToBuffer(address, config.addressPrefix),
         tro: normalizedTro
     };
 }
 
-export function normalizeTransactionOperation(payload) {
+export function normalizeTransactionOperation(payload, config) {
     if (!payload || typeof payload !== 'object' || !payload.txo) {
         throw new Error('Invalid payload for transaction operation normalization.');
     }
@@ -70,7 +71,7 @@ export function normalizeTransactionOperation(payload) {
 
     return {
         type,
-        address: addressToBuffer(address),
+        address: addressToBuffer(address, config.addressPrefix),
         txo: normalizedTxo
     };
 }
@@ -82,7 +83,7 @@ export function normalizeTransactionOperation(payload) {
  * @param {Object} payload The decoded transaction payload.
  * @returns {Object} A new object with Buffer values converted to hex strings.
  */
-export function normalizeDecodedPayloadForJson(payload) {
+export function normalizeDecodedPayloadForJson(payload, config) {
     if (!payload || typeof payload !== "object") {
         return payload;
     }
@@ -96,7 +97,7 @@ export function normalizeDecodedPayloadForJson(payload) {
             if (b4a.isBuffer(value)) {
                 // 👇 intercept address buffers by key name (e.g. `address`)
                 if (addressKeys.some(k => key.toLowerCase().includes(k))) {
-                    const addr = bufferToAddress(value);
+                    const addr = bufferToAddress(value, config.addressPrefix);
                     newPayload[key] = addr ?? b4a.toString(value, "hex");
                 } else if (key.toLowerCase().includes("am")) {
                     const amount = bufferToBigInt(value)
@@ -107,7 +108,7 @@ export function normalizeDecodedPayloadForJson(payload) {
 
             } else if (typeof value === "object" && value !== null) {
                 // recursively handle nested objects
-                newPayload[key] = normalizeDecodedPayloadForJson(value);
+                newPayload[key] = normalizeDecodedPayloadForJson(value, config);
 
             } else {
                 newPayload[key] = value;
@@ -115,4 +116,4 @@ export function normalizeDecodedPayloadForJson(payload) {
         }
     }
     return newPayload;
-}
+}

package/tests/acceptance/v1/account/account.test.mjs

@@ -1,6 +1,6 @@
 import request from "supertest"
 import { bufferToBigInt, licenseBufferToBigInt } from "../../../../src/utils/amountSerialization.js"
-import { ZERO_WK } from "../../../../rpc/constants.mjs"
+import { ZERO_WK } from "../../../../rpc/constants.js"
 import { ADMIN_INITIAL_STAKED_BALANCE } from "../../../../src/utils/constants.js"
 import { BALANCE_TO_STAKE } from "../../../../src/core/state/utils/balance.js"
 import { randomAddress } from "../../../unit/state/stateTestUtils.js"
@@ -72,7 +72,7 @@ export const registerAccountTests = (context) => {
         })
 
         it("returns default state for non-existent node", async () => {
-            const address = randomAddress()
+            const address = randomAddress(context.rpcMsb.config.addressPrefix)
 
             const res = await request(context.server).get(`/v1/account/${address}`)
             expect(res.statusCode).toBe(200)

package/tests/acceptance/v1/balance/balance.test.mjs

@@ -37,7 +37,7 @@ export const registerBalanceTests = (context) => {
         })
 
         it("returns zero balance for an unknown address", async () => {
-            const address = randomAddress()
+            const address = randomAddress(context.rpcMsb.config.addressPrefix)
             const res = await request(context.server).get(`/v1/balance/${address}`)
             expect(res.statusCode).toBe(200)
             expect(res.body.address).toBe(address)

package/tests/acceptance/v1/broadcast-transaction/broadcast-transaction.test.mjs

@@ -1,7 +1,7 @@
 import request from "supertest"
 import b4a from "b4a"
 import { $TNK } from "../../../../src/core/state/utils/balance.js"
-import { buildRpcSelfTransferPayload } from "../../../helpers/transactionPayloads.mjs"
+import { buildRpcSelfTransferPayload, waitForConnection } from "../../../helpers/transactionPayloads.mjs"
 
 const toBase64 = (value) => b4a.toString(b4a.from(JSON.stringify(value)), "base64")
 
@@ -9,10 +9,11 @@ export const registerBroadcastTransactionTests = (context) => {
     describe("POST /v1/broadcast-transaction", () => {
         it("broadcasts transaction and returns lengths", async () => {
             const { payload } = await buildRpcSelfTransferPayload(
-                context.wallet,
+                context,
                 context.rpcMsb.state,
                 1n
             );
+            await waitForConnection(context.rpcMsb)
             const res = await request(context.server)
                 .post("/v1/broadcast-transaction")
                 .set("Accept", "application/json")
@@ -30,6 +31,7 @@ export const registerBroadcastTransactionTests = (context) => {
         })
 
         it("returns 400 when payload is missing", async () => {
+            await waitForConnection(context.rpcMsb)
             const res = await request(context.server)
                 .post("/v1/broadcast-transaction")
                 .set("Accept", "application/json")
@@ -40,6 +42,7 @@ export const registerBroadcastTransactionTests = (context) => {
         })
 
         it("returns 400 when payload is not base64", async () => {
+            await waitForConnection(context.rpcMsb)
             const res = await request(context.server)
                 .post("/v1/broadcast-transaction")
                 .set("Accept", "application/json")
@@ -52,6 +55,8 @@ export const registerBroadcastTransactionTests = (context) => {
         // TODO: enable once handler returns 400 for client-side decode errors
         it.skip("returns 400 when decoded payload is not valid JSON", async () => {
             const invalidJsonBase64 = b4a.toString(b4a.from("{{invalid"), "base64")
+
+            await waitForConnection(context.rpcMsb)
             const res = await request(context.server)
                 .post("/v1/broadcast-transaction")
                 .set("Accept", "application/json")
@@ -67,6 +72,8 @@ export const registerBroadcastTransactionTests = (context) => {
                 type: 1,
                 address: context.wallet.address,
             }
+
+            await waitForConnection(context.rpcMsb)
             const res = await request(context.server)
                 .post("/v1/broadcast-transaction")
                 .set("Accept", "application/json")
@@ -81,6 +88,7 @@ export const registerBroadcastTransactionTests = (context) => {
             const largeString = "a".repeat(3_000_000)
             const payload = toBase64({ type: 1, address: context.wallet.address, txo: { large: largeString } })
 
+            await waitForConnection(context.rpcMsb)
             const res = await request(context.server)
                 .post("/v1/broadcast-transaction")
                 .set("Accept", "application/json")
@@ -99,6 +107,7 @@ export const registerBroadcastTransactionTests = (context) => {
             )
 
             const payload = tracCrypto.transaction.build(txData, b4a.from(context.wallet.secretKey, 'hex'))
+            await waitForConnection(context.rpcMsb)
             const res = await request(context.server)
                 .post("/v1/broadcast-transaction")
                 .set("Accept", "application/json")