trac-msb 0.2.7 → 0.2.9

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/cli.js

@@ -39,14 +39,6 @@ export async function verifyDag(state, network, wallet, writerKey) {
         const wl = await state.getWriterLength();
         console.log('Total Registered Writers:', wl !== null ? wl : 0);
 
-        console.log("---------- connections stats ----------");
-        console.log("Admin Stream:", network.admin_stream ? "Connected" : "Not Connected");
-        console.log("Admin Public Key:", network.admin ? network.admin.toString('hex') : "None");
-        console.log("Validator Stream:", network.validatorConnectionManager.connectionCount() > 0 ? "Connected" : "Not Connected");
-        console.log("Validator Public Key:", network.validator ? network.validator.toString('hex') : "None");
-        console.log("Custom Stream:", network.custom_stream ? "Connected" : "Not Connected");
-        console.log("Custom Node Address:", network.custom_node ? network.custom_node.toString('hex') : "None");
-
         console.log("---------- flags ----------");
         try {
             console.log(`isIndexer: ${state?.isIndexer?.() ?? 'unset'}`);

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

@@ -1,4 +1,5 @@
-import { OperationType as OP } from './protobuf/applyOperations.cjs';
+import { OperationType as ApplyOperationType } from './protobuf/applyOperations.cjs';
+import { MessageType as NetworkMessageType, ResultCode as NetworkResultCode } from './protobuf/network.cjs';
 import b4a from 'b4a'
 // TODO: We are going to have a lot of contstants. It would be good, to separate them into different files.
 
@@ -17,19 +18,37 @@ export const EntryType = Object.freeze({
 
 //ATTENTION - THIS IS USED IN THE APPLY FUNCTION!
 export const OperationType = Object.freeze({
-    ADD_ADMIN: OP.ADD_ADMIN,
-    DISABLE_INITIALIZATION: OP.DISABLE_INITIALIZATION,
-    BALANCE_INITIALIZATION: OP.BALANCE_INITIALIZATION,
-    APPEND_WHITELIST: OP.APPEND_WHITELIST,
-    ADD_WRITER: OP.ADD_WRITER,
-    REMOVE_WRITER: OP.REMOVE_WRITER,
-    ADMIN_RECOVERY: OP.ADMIN_RECOVERY,
-    ADD_INDEXER: OP.ADD_INDEXER,
-    REMOVE_INDEXER: OP.REMOVE_INDEXER,
-    BAN_VALIDATOR: OP.BAN_VALIDATOR,
-    BOOTSTRAP_DEPLOYMENT: OP.BOOTSTRAP_DEPLOYMENT,
-    TX: OP.TX,
-    TRANSFER: OP.TRANSFER,
+    ADD_ADMIN: ApplyOperationType.ADD_ADMIN,
+    DISABLE_INITIALIZATION: ApplyOperationType.DISABLE_INITIALIZATION,
+    BALANCE_INITIALIZATION: ApplyOperationType.BALANCE_INITIALIZATION,
+    APPEND_WHITELIST: ApplyOperationType.APPEND_WHITELIST,
+    ADD_WRITER: ApplyOperationType.ADD_WRITER,
+    REMOVE_WRITER: ApplyOperationType.REMOVE_WRITER,
+    ADMIN_RECOVERY: ApplyOperationType.ADMIN_RECOVERY,
+    ADD_INDEXER: ApplyOperationType.ADD_INDEXER,
+    REMOVE_INDEXER: ApplyOperationType.REMOVE_INDEXER,
+    BAN_VALIDATOR: ApplyOperationType.BAN_VALIDATOR,
+    BOOTSTRAP_DEPLOYMENT: ApplyOperationType.BOOTSTRAP_DEPLOYMENT,
+    TX: ApplyOperationType.TX,
+    TRANSFER: ApplyOperationType.TRANSFER,
+});
+
+export const NetworkOperationType = Object.freeze({
+    VALIDATOR_CONNECTION_REQUEST: NetworkMessageType.MESSAGE_TYPE_VALIDATOR_CONNECTION_REQUEST,
+    VALIDATOR_CONNECTION_RESPONSE: NetworkMessageType.MESSAGE_TYPE_VALIDATOR_CONNECTION_RESPONSE,
+    LIVENESS_REQUEST: NetworkMessageType.MESSAGE_TYPE_LIVENESS_REQUEST,
+    LIVENESS_RESPONSE: NetworkMessageType.MESSAGE_TYPE_LIVENESS_RESPONSE,
+    BROADCAST_TRANSACTION_REQUEST: NetworkMessageType.MESSAGE_TYPE_BROADCAST_TRANSACTION_REQUEST,
+    BROADCAST_TRANSACTION_RESPONSE: NetworkMessageType.MESSAGE_TYPE_BROADCAST_TRANSACTION_RESPONSE,
+});
+
+export const ResultCode = Object.freeze({
+    OK: NetworkResultCode.RESULT_CODE_OK,
+    INVALID_PAYLOAD: NetworkResultCode.RESULT_CODE_INVALID_PAYLOAD,
+    UNSUPPORTED_VERSION: NetworkResultCode.RESULT_CODE_UNSUPPORTED_VERSION,
+    RATE_LIMITED: NetworkResultCode.RESULT_CODE_RATE_LIMITED,
+    TIMEOUT: NetworkResultCode.RESULT_CODE_TIMEOUT,
+    SIGNATURE_INVALID: NetworkResultCode.RESULT_CODE_SIGNATURE_INVALID,
 });
 
 // Role managment constants
@@ -40,6 +59,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,8 +87,8 @@ 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;
 export const AUTOBASE_VALUE_ENCODING = 'binary';
@@ -119,12 +140,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_IN_CONNECTION_POOL = 50;
-export const MAX_MESSAGE_SEND_ATTEMPTS = 3;
-export const MESSAGE_VALIDATOR_RETRY_DELAY_MS = 1000;
-export const MESSAGE_VALIDATOR_RESPONSE_TIMEOUT_MS = 3 * MAX_MESSAGE_SEND_ATTEMPTS * MESSAGE_VALIDATOR_RETRY_DELAY_MS;
-export const MAX_SUCCESSIVE_MESSAGES_PER_VALIDATOR = 3;

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,27 @@ 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) {
+/**
+ * Normalizes the payload for a transaction operation.
+ * This is useful for validating and assembling a transaction operation.
+ *
+ * @param {Object} payload The raw payload for the transaction operation.
+ * @param {object} config The environment configuration object.
+ * @returns {Object} A normalized payload with addresses converted to buffers and hex values normalized.
+ */
+export function normalizeTransactionOperation(payload, config) {
     if (!payload || typeof payload !== 'object' || !payload.txo) {
         throw new Error('Invalid payload for transaction operation normalization.');
     }
@@ -70,7 +79,7 @@ export function normalizeTransactionOperation(payload) {
 
     return {
         type,
-        address: addressToBuffer(address),
+        address: addressToBuffer(address, config.addressPrefix),
         txo: normalizedTxo
     };
 }
@@ -79,10 +88,11 @@ export function normalizeTransactionOperation(payload) {
  * Normalizes an operation payload by converting any Buffer values to hex strings.
  * This is useful for preparing a payload to be returned as a JSON response.
  *
- * @param {Object} payload The decoded transaction payload.
- * @returns {Object} A new object with Buffer values converted to hex strings.
+ * @param {Object} payload The raw payload for the role access operation.
+ * @param {object} config The environment configuration object.
+ * @returns {Object} A normalized payload with addresses converted to buffers and hex values normalized.
  */
-export function normalizeDecodedPayloadForJson(payload) {
+export function normalizeDecodedPayloadForJson(payload, config) {
     if (!payload || typeof payload !== "object") {
         return payload;
     }
@@ -96,7 +106,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 +117,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 +125,77 @@ export function normalizeDecodedPayloadForJson(payload) {
         }
     }
     return newPayload;
-}
+}
+
+/**
+ * Normalizes the payload for a role access operation.
+ * This is useful for validating and assembling a role access operation.
+ *
+ * @param {Object} payload The raw payload for the role access operation.
+ * @param {object} config The environment configuration object.
+ * @returns {Object} A normalized payload with addresses converted to buffers and hex values normalized.
+ */
+export function normalizeRoleAccessOperation(payload, config) {
+    if (!payload || typeof payload !== 'object' || !payload.rao) {
+        throw new Error('Invalid payload for role access normalization.');
+    }
+    const { type, address, rao } = payload;
+    if (
+        !type ||
+        !address ||
+        !rao.tx || !rao.txv || !rao.iw || !rao.in || !rao.is
+    ) {
+        throw new Error('Missing required fields in role access payload.');
+    }
+
+    const normalizedRao = {
+        tx: normalizeHex(rao.tx),
+        txv: normalizeHex(rao.txv),
+        iw: normalizeHex(rao.iw),
+        in: normalizeHex(rao.in),
+        is: normalizeHex(rao.is)
+    };
+
+    return {
+        type,
+        address: addressToBuffer(address, config.addressPrefix),
+        rao: normalizedRao
+    };
+}
+
+/**
+ * Normalizes the payload for a bootstrap deployment operation.
+ * This is useful for validating and assembling a bootstrap deployment operation.
+ *
+ * @param {Object} payload The raw payload for the bootstrap deployment operation.
+ * @param {object} config The environment configuration object.
+ * @returns {Object} A normalized payload with addresses converted to buffers and hex values normalized.
+ */
+export function normalizeBootstrapDeploymentOperation(payload, config) {
+    if (!payload || typeof payload !== 'object' || !payload.bdo) {
+        throw new Error('Invalid payload for bootstrap deployment normalization.');
+    }
+    const { type, address, bdo } = payload;
+    if (
+        type !== OperationType.BOOTSTRAP_DEPLOYMENT ||
+        !address ||
+        !bdo.tx || !bdo.bs || !bdo.ic || !bdo.in || !bdo.is || !bdo.txv
+    ) {
+        throw new Error('Missing required fields in bootstrap deployment payload.');
+    }
+
+    const normalizedBdo = {
+        tx: normalizeHex(bdo.tx),   // Transaction hash
+        txv: normalizeHex(bdo.txv), // Transaction validity
+        bs: normalizeHex(bdo.bs),   // External bootstrap
+        ic: normalizeHex(bdo.ic),   // Channel
+        in: normalizeHex(bdo.in),   // Nonce
+        is: normalizeHex(bdo.is)    // Signature
+    };
+
+    return {
+        type,
+        address: addressToBuffer(address, config.addressPrefix),
+        bdo: normalizedBdo
+    };
+}