trac-msb 0.2.7 → 0.2.8

package/src/core/network/Network.js

@@ -2,7 +2,6 @@ import ReadyResource from 'ready-resource';
 import Hyperswarm from 'hyperswarm';
 import w from 'protomux-wakeup';
 import b4a from 'b4a';
-
 import TransactionPoolService from './services/TransactionPoolService.js';
 import ValidatorObserverService from './services/ValidatorObserverService.js';
 import NetworkMessages from './messaging/NetworkMessages.js';
@@ -13,37 +12,54 @@ import {
     MAX_PARALLEL,
     MAX_SERVER_CONNECTIONS,
     MAX_CLIENT_CONNECTIONS,
-    NETWORK_MESSAGE_TYPES,
-    DHT_BOOTSTRAPS
+    NETWORK_MESSAGE_TYPES
 } from '../../utils/constants.js';
 import ConnectionManager from './services/ConnectionManager.js';
 import MessageOrchestrator from './services/MessageOrchestrator.js';
 import NetworkWalletFactory from './identity/NetworkWalletFactory.js';
+import { EventType } from '../../utils/constants.js';
+
+// -- Debug Mode --
+// TODO: Implement a better debug system in the future. This is just temporary.
+const DEBUG = false;
+const debugLog = (...args) => {
+    if (DEBUG) {
+        console.log('DEBUG [Network] ==> ', ...args);
+    }
+};
+
 const wakeup = new w();
 
 class Network extends ReadyResource {
-    #dht_bootstrap = DHT_BOOTSTRAPS;
     #swarm = null;
-    #enable_wallet;
-    #channel;
     #networkMessages;
     #transactionPoolService;
     #validatorObserverService;
     #validatorConnectionManager;
     #validatorMessageOrchestrator;
-    #options;
+    #config;
     #identityProvider = null;
-
-    constructor(state, channel, address = null, options = {}) {
+    #pendingConnections;
+    #connectTimeoutMs;
+    #maxPendingConnections;
+
+    /**
+     * @param {State} state
+     * @param {object} config
+     * @param {string} address
+     **/
+    constructor(state, config, address = null) {
         super();
-        this.#options = options;
-        this.#enable_wallet = options.enable_wallet !== false;
-        this.#channel = channel;
-        this.#transactionPoolService = new TransactionPoolService(state, address, options);
-        this.#validatorObserverService = new ValidatorObserverService(this, state, address, options);
-        this.#networkMessages = new NetworkMessages(this, options);
-        this.#validatorConnectionManager = new ConnectionManager({ maxValidators: options.max_validators });
-        this.#validatorMessageOrchestrator = new MessageOrchestrator(this.#validatorConnectionManager, state);
+        this.#config = config
+        this.#connectTimeoutMs = config.connectTimeoutMs || 5000;
+        this.#maxPendingConnections = config.maxPendingConnections || 50;
+
+        this.#pendingConnections = new Map();
+        this.#transactionPoolService = new TransactionPoolService(state, address, this.#config);
+        this.#validatorObserverService = new ValidatorObserverService(this, state, address, this.#config);
+        this.#networkMessages = new NetworkMessages(this, this.#config);
+        this.#validatorConnectionManager = new ConnectionManager(this.#config);
+        this.#validatorMessageOrchestrator = new MessageOrchestrator(this.#validatorConnectionManager, state, this.#config);
         this.admin_stream = null;
         this.admin = null;
         this.validator = null;
@@ -55,10 +71,6 @@ class Network extends ReadyResource {
         return this.#swarm;
     }
 
-    get channel() {
-        return this.#channel;
-    }
-
     get transactionPoolService() {
         return this.#transactionPoolService;
     }
@@ -77,6 +89,9 @@ class Network extends ReadyResource {
 
     async _open() {
         console.log('Network initialization...');
+
+        this.setupNetworkListeners();
+
         this.transactionPoolService.start();
         this.validatorObserverService.start();
     }
@@ -88,11 +103,53 @@ class Network extends ReadyResource {
         this.#validatorObserverService.stopValidatorObserver();
         await sleep(5_000);
 
+        this.cleanupNetworkListeners();
+        this.cleanupPendingConnections();
+
         if (this.#swarm !== null) {
             this.#swarm.destroy();
         }
     }
 
+    setupNetworkListeners() {
+        // VALIDATOR_CONNECTION_TIMEOUT
+        this.on(EventType.VALIDATOR_CONNECTION_TIMEOUT, ({ publicKey, type, timeoutMs }) => {
+            debugLog(`Network Event: VALIDATOR_CONNECTION_TIMEOUT | PublicKey: ${publicKey} | Type: ${type} | TimeoutMs: ${timeoutMs}`);
+            this.#pendingConnections.delete(publicKey);
+        });
+
+        // VALIDATOR_CONNECTION_READY
+        this.on(EventType.VALIDATOR_CONNECTION_READY, ({ publicKey, type, connection }) => {
+            debugLog(`Network Event: VALIDATOR_CONNECTION_READY | PublicKey: ${publicKey} | Type: ${type}`);
+            const { timeoutId } = this.#pendingConnections.get(publicKey);
+            if (!timeoutId) return;
+
+            clearTimeout(timeoutId);
+            this.#pendingConnections.delete(publicKey);
+
+            if (type === 'validator') {
+                const target = b4a.from(publicKey, 'hex');
+                this.#validatorConnectionManager.addValidator(target, connection);
+                this.#sendRequestByType(connection, type);
+            }
+        });
+    }
+
+    cleanupNetworkListeners() {
+        // connect:timeout
+        this.removeAllListeners('connect:timeout');
+
+        // connect:ready
+        this.removeAllListeners('connect:ready');
+    }
+
+    cleanupPendingConnections() {
+        for (const { timeoutId } of this.#pendingConnections.values()) {
+            clearTimeout(timeoutId);
+        }
+        this.#pendingConnections.clear();
+    }
+
     async replicate(
         state,
         store,
@@ -103,14 +160,14 @@ class Network extends ReadyResource {
             const wrappedWallet = this.#getNetworkWalletWrapper(wallet, keyPair);
             this.#swarm = new Hyperswarm({
                 keyPair,
-                bootstrap: this.#dht_bootstrap,
+                bootstrap: this.#config.dhtBootstrap,
                 maxPeers: MAX_PEERS,
                 maxParallel: MAX_PARALLEL,
                 maxServerConnections: MAX_SERVER_CONNECTIONS,
                 maxClientConnections: MAX_CLIENT_CONNECTIONS
             });
 
-            console.log(`Channel: ${b4a.toString(this.#channel)}`);
+            console.log(`Channel: ${b4a.toString(this.#config.channel)}`);
             this.#networkMessages.initializeMessageRouter(state, wrappedWallet);
 
             this.#swarm.on('connection', async (connection) => {
@@ -121,6 +178,12 @@ class Network extends ReadyResource {
                 const stream = store.replicate(connection);
                 wakeup.addStream(stream);
 
+                const publicKey = b4a.toString(connection.remotePublicKey, 'hex');
+                if (this.#pendingConnections.has(publicKey)) {
+                    const { type } = this.#pendingConnections.get(publicKey);
+                    await this.#finalizeConnection(publicKey, type, connection);
+                }
+
                 connection.on('close', () => {
                     if (this.admin_stream === connection) {
                         this.admin_stream = null;
@@ -151,13 +214,21 @@ class Network extends ReadyResource {
 
             });
 
-            this.#swarm.join(this.#channel, { server: true, client: true });
+            this.#swarm.join(this.#config.channel, { server: true, client: true });
             this.#swarm.flush();
         }
     }
 
+    isConnectionPending(publicKey) {
+        return this.#pendingConnections.has(publicKey);
+    }
+
+    pendingConnectionsCount() {
+        return this.#pendingConnections.size;
+    }
+
     async initializeNetworkingKeyPair(store, wallet) {
-        if (!this.#enable_wallet) {
+        if (!this.#config.enableWallet) {
             return await store.createKeyPair(TRAC_NAMESPACE);
         } else {
             return {
@@ -169,34 +240,29 @@ class Network extends ReadyResource {
 
     async tryConnect(publicKey, type = null) {
         if (this.#swarm === null) throw new Error('Network swarm is not initialized');
+        if (this.#pendingConnections.has(publicKey) || this.#pendingConnections.size >= this.#maxPendingConnections) {
+            debugLog(`Network.tryConnect: Connection to peer: ${publicKey} as type: ${type} is already pending or max pending connections reached.`);
+            return;
+        }
+
+        const timeoutId = setTimeout(() => {
+            if (!this.#pendingConnections.has(publicKey)) return;
+            this.emit(EventType.VALIDATOR_CONNECTION_TIMEOUT, { publicKey, type, timeoutMs: this.#connectTimeoutMs });
+        }, this.#connectTimeoutMs);
+        this.#pendingConnections.set(publicKey, { type, timeoutId });
 
         const target = b4a.from(publicKey, 'hex');
         if (!this.#swarm.peers.has(publicKey)) {
             this.#swarm.joinPeer(target);
-            let cnt = 0;
-            while (!this.#swarm.peers.has(publicKey) && cnt < 1500) { // TODO: Get rid of the magic number and add a config option for this
-                await sleep(10);
-                cnt += 1;
-            }
         }
 
         const peerInfo = this.#swarm.peers.get(publicKey);
-        if (!peerInfo) return;
-
-        // Wait for the swarm to establish the connection and for protomux to attach
-        let stream = this.#swarm._allConnections.get(peerInfo.publicKey);
-        let attempts = 0;
-        while ((!stream || !stream.messenger) && attempts < 1500) { // TODO: Get rid of the magic number and add a config option
-            await sleep(10);
-            attempts += 1;
-            stream = this.#swarm._allConnections.get(peerInfo.publicKey);
-        }
-        if (!stream || !stream.messenger) return;
-
-        if (type === 'validator') {
-            this.#validatorConnectionManager.addValidator(target, stream);
+        if (peerInfo) {
+            const connection = this.#swarm._allConnections.get(peerInfo.publicKey);
+            if (connection && connection.messenger) {
+                await this.#finalizeConnection(publicKey, type, connection);
+            }
         }
-        await this.#sendRequestByType(stream, type);
     }
 
     async isConnected(publicKey) {
@@ -204,6 +270,12 @@ class Network extends ReadyResource {
             this.#swarm.peers.get(publicKey).connectedTime != -1
     }
 
+    async #finalizeConnection(publicKey, type, connection) {
+        if (!this.#pendingConnections.has(publicKey)) return;
+        this.emit(EventType.VALIDATOR_CONNECTION_READY, { publicKey, type, connection });
+        debugLog(`Network.finalizeConnection: Connected to peer: ${publicKey} as type: ${type}`);
+    }
+
     async #sendRequestByType(stream, type) {
         const waitFor = {
             validator: () => this.validatorConnectionManager.connectionCount(),
@@ -231,39 +303,13 @@ class Network extends ReadyResource {
         }
     }
 
-    async sendMessageToNode(nodePublicKey, message) {
-        try {
-            if (!nodePublicKey || !message) {
-                return;
-            }
-            await this.tryConnect(nodePublicKey, 'node');
-
-            await this.spinLock(() =>
-                this.custom_stream === null ||
-                !b4a.equals(this.custom_node, b4a.from(nodePublicKey, 'hex'))
-            );
-            if (
-                this.custom_stream !== null &&
-                this.custom_node !== null &&
-                b4a.equals(this.custom_node, b4a.from(nodePublicKey, 'hex'))
-            ) {
-                await this.custom_stream.messenger.send(message);
-            } else {
-                throw new Error(`Failed to send message to node: ${nodePublicKey}`);
-            }
-
-        } catch (e) {
-            console.log(e)
-        }
-    }
-
     #getNetworkWalletWrapper(wallet, keyPair) {
         if (!this.#identityProvider) {
             this.#identityProvider = NetworkWalletFactory.provide({
-                enableWallet: this.#enable_wallet,
+                enableWallet: this.#config.enableWallet,
                 wallet,
                 keyPair,
-                networkPrefix: this.#options?.networkPrefix
+                networkPrefix: this.#config.addressPrefix
             });
         }
         return this.#identityProvider;

package/src/core/network/identity/NetworkWalletFactory.js

@@ -1,14 +1,13 @@
 import PeerWallet from 'trac-wallet';
-import { TRAC_NETWORK_MSB_MAINNET_PREFIX } from 'trac-wallet/constants.js';
 import b4a from 'b4a';
 
 export class NetworkWalletFactory {
     static provide(options = {}) {
         const {
-            enableWallet = true,
+            enableWallet,
             wallet,
             keyPair,
-            networkPrefix = TRAC_NETWORK_MSB_MAINNET_PREFIX
+            networkPrefix
         } = options;
 
         if (enableWallet) {
@@ -34,7 +33,7 @@ class EphemeralWallet {
     #secretKey;
     #address;
 
-    constructor(keyPair, networkPrefix = TRAC_NETWORK_MSB_MAINNET_PREFIX) {
+    constructor(keyPair, networkPrefix) {
         
         if (!keyPair?.publicKey || !keyPair?.secretKey) {
             throw new Error('NetworkIdentityProvider: keyPair with publicKey and secretKey is required');

package/src/core/network/messaging/NetworkMessages.js

@@ -3,27 +3,28 @@ import Protomux from 'protomux';
 import b4a from 'b4a';
 import c from 'compact-encoding';
 import NetworkMessageRouter from './routes/NetworkMessageRouter.js';
+import Network from '../Network.js';
 
 class NetworkMessages {
     #messageRouter;
     #network;
-    #options;
+    #config;
 
-    constructor(network, options = {}) {
+    /**
+     * @param {Network} network
+     * @param {object} config
+     **/
+    constructor(network, config) {
         this.#network = network;
-        this.#options = options;
-    }
-
-    get network() {
-        return this.#network;
+        this.#config = config;
     }
 
     initializeMessageRouter(state, wallet) {
         this.#messageRouter = new NetworkMessageRouter(
-            this.network,
+            this.#network,
             state,
             wallet,
-            this.#options
+            this.#config
         );
     }
 
@@ -31,7 +32,7 @@ class NetworkMessages {
         const mux = Protomux.from(connection);
         connection.userData = mux;
         const message_channel = mux.createChannel({
-            protocol: b4a.toString(this.network.channel, 'utf8'),
+            protocol: b4a.toString(this.#config.channel, 'utf8'),
             onopen() { },
             onclose() { }
         });
@@ -50,7 +51,7 @@ class NetworkMessages {
                 } catch (error) {
                     console.error(`NetworkMessages: Failed to handle incoming message: ${error.message}`);
                 } finally {
-                    this.network.swarm.leavePeer(connection.remotePublicKey);
+                    this.#network.swarm.leavePeer(connection.remotePublicKey);
                 }
             }
         });

package/src/core/network/messaging/handlers/GetRequestHandler.js

@@ -1,7 +1,6 @@
 import { NETWORK_MESSAGE_TYPES } from '../../../../utils/constants.js';
 import PeerWallet from 'trac-wallet';
 import b4a from 'b4a';
-import { blake3Hash } from '../../../../utils/crypto.js';
 
 class GetRequestHandler {
     #wallet;
@@ -44,7 +43,9 @@ class GetRequestHandler {
             timestamp: Date.now(),
         };
 
-        const hash = await blake3Hash(JSON.stringify(payload));
+
+        const hashInput = b4a.from(JSON.stringify(payload), 'utf8');
+        const hash = await PeerWallet.blake3(hashInput);
         const sig = this.#wallet.sign(hash);
 
         const responseMessage = {
@@ -76,7 +77,7 @@ class GetRequestHandler {
             issuer: connection.remotePublicKey.toString('hex'),
             timestamp: Date.now(),
         };
-        const hash = await blake3Hash(JSON.stringify(payload));
+        const hash = await PeerWallet.blake3(JSON.stringify(payload));
         const sig = this.#wallet.sign(hash);
 
         const responseMessage = {
@@ -97,7 +98,7 @@ class GetRequestHandler {
             timestamp: Date.now(),
         };
         
-        const hash = await blake3Hash(JSON.stringify(payload));
+        const hash = await PeerWallet.blake3(JSON.stringify(payload));
         const sig = this.#wallet.sign(hash);
 
         const responseMessage = {

package/src/core/network/messaging/handlers/ResponseHandler.js

@@ -3,7 +3,6 @@ import ValidatorResponse from '../validators/ValidatorResponse.js';
 import AdminResponse from '../validators/AdminResponse.js';
 import CustomNodeResponse from '../validators/CustomNodeResponse.js';
 import PeerWallet from 'trac-wallet';
-import b4a from "b4a";
 
 class ResponseHandler {
     #network;
@@ -12,12 +11,12 @@ class ResponseHandler {
     #adminValidator;
     #customNodeValidator;
     
-    constructor(network, state, wallet) {
+    constructor(network, state, wallet, config) {
         this.#network = network;
         this.#state = state;
-        this.#responseValidator = new ValidatorResponse(this.state, wallet);
-        this.#adminValidator = new AdminResponse(this.state, wallet);
-        this.#customNodeValidator = new CustomNodeResponse(this.state, wallet);
+        this.#responseValidator = new ValidatorResponse(this.state, wallet, config);
+        this.#adminValidator = new AdminResponse(this.state, wallet, config);
+        this.#customNodeValidator = new CustomNodeResponse(this.state, wallet, config);
 
     }
 

package/src/core/network/messaging/handlers/RoleOperationHandler.js

@@ -10,20 +10,21 @@ class RoleOperationHandler extends BaseOperationHandler {
     #partialRoleAccessValidator;
     #wallet;
     #network;
+    #config;
 
-    constructor(network, state, wallet, rateLimiter, options = {}) {
-        super(network, state, wallet, rateLimiter, options);
+    /**
+     * @param {Network} network
+     * @param {State} state
+     * @param {PeerWallet} wallet
+     * @param {TransactionRateLimiterService} rateLimiter
+     * @param {object} config
+     **/
+    constructor(network, state, wallet, rateLimiter, config) {
+        super(network, state, wallet, rateLimiter, config);
         this.#wallet = wallet;
+        this.#config = config;
         this.#network = network;
-        this.#partialRoleAccessValidator = new PartialRoleAccess(state)
-    }
-
-    get wallet() {
-        return this.#wallet;
-    }
-
-    get network() {
-        return this.#network;
+        this.#partialRoleAccessValidator = new PartialRoleAccess(state, wallet ,this.#config)
     }
 
     get partialRoleAccessValidator() {
@@ -40,8 +41,7 @@ class RoleOperationHandler extends BaseOperationHandler {
         
         switch (normalizedPartialRoleAccessPayload.type) {
             case OperationType.ADD_WRITER:
-                completePayload = await CompleteStateMessageOperations.assembleAddWriterMessage(
-                    this.wallet,
+                completePayload = await new CompleteStateMessageOperations(this.#wallet, this.#config).assembleAddWriterMessage(
                     normalizedPartialRoleAccessPayload.address,
                     normalizedPartialRoleAccessPayload.rao.tx,
                     normalizedPartialRoleAccessPayload.rao.txv,
@@ -51,8 +51,7 @@ class RoleOperationHandler extends BaseOperationHandler {
                 );
                 break;
             case OperationType.REMOVE_WRITER:
-                completePayload = await CompleteStateMessageOperations.assembleRemoveWriterMessage(
-                    this.wallet,
+                completePayload = await new CompleteStateMessageOperations(this.#wallet, this.#config).assembleRemoveWriterMessage(
                     normalizedPartialRoleAccessPayload.address,
                     normalizedPartialRoleAccessPayload.rao.tx,
                     normalizedPartialRoleAccessPayload.rao.txv,
@@ -62,8 +61,7 @@ class RoleOperationHandler extends BaseOperationHandler {
                 );
                 break;
             case OperationType.ADMIN_RECOVERY:
-                completePayload = await CompleteStateMessageOperations.assembleAdminRecoveryMessage(
-                    this.wallet,
+                completePayload = await new CompleteStateMessageOperations(this.#wallet, this.#config).assembleAdminRecoveryMessage(
                     normalizedPartialRoleAccessPayload.address,
                     normalizedPartialRoleAccessPayload.rao.tx,
                     normalizedPartialRoleAccessPayload.rao.txv,
@@ -81,7 +79,7 @@ class RoleOperationHandler extends BaseOperationHandler {
             throw new Error("OperationHandler: Assembling complete role access operation failed.");
         }
 
-        this.network.transactionPoolService.addTransaction(completePayload)
+        this.#network.transactionPoolService.addTransaction(completePayload)
     }
 
     #normalizePartialRoleAccess(payload) {
@@ -107,7 +105,7 @@ class RoleOperationHandler extends BaseOperationHandler {
 
         return {
             type,
-            address: addressToBuffer(address),
+            address: addressToBuffer(address, this.#config.addressPrefix),
             rao: normalizedRao
         };
     }

package/src/core/network/messaging/handlers/SubnetworkOperationHandler.js

@@ -1,28 +1,34 @@
 import BaseOperationHandler from './base/BaseOperationHandler.js';
-import CompleteStateMessageOperations from "../../../../messages/completeStateMessages/CompleteStateMessageOperations.js";
+import CompleteStateMessageOperations
+    from "../../../../messages/completeStateMessages/CompleteStateMessageOperations.js";
 import {
     OperationType
 } from '../../../../utils/constants.js';
 import PartialBootstrapDeployment from "../validators/PartialBootstrapDeployment.js";
-import {addressToBuffer, bufferToAddress} from "../../../state/utils/address.js";
+import {addressToBuffer} from "../../../state/utils/address.js";
 import PartialTransaction from "../validators/PartialTransaction.js";
 import {normalizeHex} from "../../../../utils/helpers.js";
 
-/**
- * THIS CLASS IS ULTRA IMPORTANT BECAUSE IF SOMEONE WILL SEND A TRASH TO VALIDATOR AND IT WON'T BE HANDLED PROPERTLY -
- * FOR EXAMPLE VALIDATOR WILL BROADCAST IT TO THE INDEXER LAYER THEN IT WILL BE BANNED. SO EVERYTHING WHAT IS TRASH
- * MUST BE REFUSED.
- * TODO: WE SHOULD AUDIT VALIDATORS AND MAKE SURE THEY ARE NOT BROADCASTING TRASH TO THE INDEXER LAYER.
- */
 
 class SubnetworkOperationHandler extends BaseOperationHandler {
     #partialBootstrapDeploymentValidator;
     #partialTransactionValidator;
-
-    constructor(network, state, wallet, rateLimiter, options = {}) {
-        super(network, state, wallet, rateLimiter, options);
-        this.#partialBootstrapDeploymentValidator = new PartialBootstrapDeployment(this.state);
-        this.#partialTransactionValidator = new PartialTransaction(this.state);
+    #config;
+    #wallet;
+
+    /**
+     * @param {Network} network
+     * @param {State} state
+     * @param {PeerWallet} wallet
+     * @param {TransactionRateLimiterService} rateLimiter
+     * @param {object} config
+     **/
+    constructor(network, state, wallet, rateLimiter, config) {
+        super(network, state, wallet, rateLimiter, config);
+        this.#config = config
+        this.#wallet = wallet
+        this.#partialBootstrapDeploymentValidator = new PartialBootstrapDeployment(state, wallet, config);
+        this.#partialTransactionValidator = new PartialTransaction(state, wallet, config);
     }
 
     async handleOperation(payload) {
@@ -36,24 +42,24 @@ class SubnetworkOperationHandler extends BaseOperationHandler {
     }
 
     async #partialTransactionSubHandler(payload) {
-        const normalizedPayload = this.#normalizeTransactionOperation(payload);
+        const normalizedPayload = this.#normalizeTransactionOperation(payload, this.#config);
         const isValid = await this.#partialTransactionValidator.validate(normalizedPayload);
         if (!isValid) {
             throw new Error("SubnetworkHandler: Transaction validation failed.");
         }
 
-        const completeTransactionOperation = await CompleteStateMessageOperations.assembleCompleteTransactionOperationMessage(
-            this.wallet,
-            normalizedPayload.address,
-            normalizedPayload.txo.tx,
-            normalizedPayload.txo.txv,
-            normalizedPayload.txo.iw,
-            normalizedPayload.txo.in,
-            normalizedPayload.txo.ch,
-            normalizedPayload.txo.is,
-            normalizedPayload.txo.bs,
-            normalizedPayload.txo.mbs
-        );
+        const completeTransactionOperation = await new CompleteStateMessageOperations(this.#wallet, this.#config)
+            .assembleCompleteTransactionOperationMessage(
+                normalizedPayload.address,
+                normalizedPayload.txo.tx,
+                normalizedPayload.txo.txv,
+                normalizedPayload.txo.iw,
+                normalizedPayload.txo.in,
+                normalizedPayload.txo.ch,
+                normalizedPayload.txo.is,
+                normalizedPayload.txo.bs,
+                normalizedPayload.txo.mbs
+            );
         this.network.transactionPoolService.addTransaction(completeTransactionOperation);
     }
 
@@ -64,16 +70,16 @@ class SubnetworkOperationHandler extends BaseOperationHandler {
             throw new Error("SubnetworkHandler: Bootstrap deployment validation failed.");
         }
 
-        const completeBootstrapDeploymentOperation = await CompleteStateMessageOperations.assembleCompleteBootstrapDeployment(
-            this.wallet,
-            normalizedPayload.address,
-            normalizedPayload.bdo.tx,
-            normalizedPayload.bdo.txv,
-            normalizedPayload.bdo.bs,
-            normalizedPayload.bdo.ic,
-            normalizedPayload.bdo.in,
-            normalizedPayload.bdo.is,
-        )
+        const completeBootstrapDeploymentOperation = await new CompleteStateMessageOperations(this.#wallet, this.#config)
+            .assembleCompleteBootstrapDeployment(
+                normalizedPayload.address,
+                normalizedPayload.bdo.tx,
+                normalizedPayload.bdo.txv,
+                normalizedPayload.bdo.bs,
+                normalizedPayload.bdo.ic,
+                normalizedPayload.bdo.in,
+                normalizedPayload.bdo.is,
+            )
         this.network.transactionPoolService.addTransaction(completeBootstrapDeploymentOperation);
 
     }
@@ -102,7 +108,7 @@ class SubnetworkOperationHandler extends BaseOperationHandler {
 
         return {
             type,
-            address: addressToBuffer(address),
+            address: addressToBuffer(address, this.#config.addressPrefix),
             bdo: normalizedBdo
         };
     }
@@ -134,7 +140,7 @@ class SubnetworkOperationHandler extends BaseOperationHandler {
 
         return {
             type,
-            address: addressToBuffer(address),
+            address: addressToBuffer(address, this.#config.addressPrefix),
             txo: normalizedTxo
         };
     }