trac-msb 0.2.17 → 0.2.19

package/src/config/env.js

@@ -1,6 +1,6 @@
-import { TRAC_NETWORK_MSB_MAINNET_PREFIX, TRAC_NETWORK_MSB_TESTNET1_PREFIX } from 'trac-wallet/constants.js';
-import { Config } from './config.js';
+import { TRAC_NETWORK_MSB_MAINNET_PREFIX, TRAC_NETWORK_MSB_TESTNET1_PREFIX } from 'trac-wallet';
 import { TRAC_NETWORK_TESTNET_ID, TRAC_NETWORK_MAINNET_ID } from 'trac-crypto-api/constants.js';
+import { Config } from './config.js';
 import { address } from 'trac-crypto-api';
 
 export const ENV = {
@@ -8,28 +8,35 @@ export const ENV = {
     DEVELOPMENT: 'development',
     TESTNET1: 'testnet1'
 }
-// TODO: CREATE TEST ENV CONFIG SIMILAR TO MAINNET AND USE IT IN TESTS.
 
 const configData = {
     [ENV.TESTNET1]: {
+        debug: false,
         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: 'c184f4ad8e9cf5e911f9415b60e7dcfb30aed73ebd8a402ef68e1b154624f5ef',
         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
+        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
         derivationPath: address.TESNET_DERIVATION_PATH,
+        enableValidatorObserver: true,
+        pollInterval: 500, // Validator observer poll interval
+        adminCacheTTL: 10_000, // Admin cache TTL ms
+        validatorConnectionAttemptDelay: 5, // Delay between validator connection attempts (ms)
+        bootstrapTimeout: 60_000, // time used (ms) to connect to new validators at bootstrap
+        writersShortCacheTTL: 10_000, // short TTL during bootstrap
+        writersLongCacheTTL: 120_000, // long TTL after bootstrap
+        maxValidators: 50,
+        maxWritersForAdminIndexerConnection: 10, // Connectivity constants
         disableRateLimit: false,
         enableErrorApplyLogs: true,
         enableInteractiveMode: true,
         enableRoleRequester: false,
         enableTxApplyLogs: true,
-        enableValidatorObserver: true,
         enableWallet: true,
-        maxValidators: 6,
-        maxRetries: 1,
-        messageThreshold: 1000,
+        maxRetries: 3,
+        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;
         host: 'localhost',
@@ -39,33 +46,44 @@ const configData = {
         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/',
+        maxPendingRequestsInPendingRequestsService: 50_000, // Maximum number of pending requests in PendingRequestService (This value should not exceed 256MB)
+        pendingRequestTimeout: 3000, // constant after which time the transaction will be considered invalid
+        txCommitTimeout: 2200,
+        txPoolSize: 1000, // size of transaction pool
+        validatorHealthCheckInterval: 5 * 60 * 1000, // How often to check validator health (ms)
+        storesDirectory: 'stores/',
         storeName: 'testnet',
     },
     [ENV.MAINNET]: {
+        debug: false,
         addressLength: 63,
         addressPrefix: TRAC_NETWORK_MSB_MAINNET_PREFIX,
         addressPrefixLength: TRAC_NETWORK_MSB_MAINNET_PREFIX.length,
         bech32mHrpLength: TRAC_NETWORK_MSB_MAINNET_PREFIX.length + 1, // len(addressPrefix + separator)
         bootstrap: 'acbc3a4344d3a804101d40e53db1dda82b767646425af73599d4cd6577d69685',
         channel: '0000trac0network0msb0mainnet0000',
-        dhtBootstrap: ['116.202.214.149:10001', '157.180.12.214:10001', 'node1.hyperdht.org:49737', 'node2.hyperdht.org:49737', 'node3.hyperdht.org:49737'],
+        dhtBootstrap: ['116.202.214.149:10001','157.180.12.214:10001','node1.hyperdht.org:49737','node2.hyperdht.org:49737','node3.hyperdht.org:49737'],
         derivationPath: address.MAINNET_DERIVATION_PATH,
+        enableValidatorObserver: true,
+        pollInterval: 500, // Validator observer poll interval
+        adminCacheTTL: 3_600_000, // Admin cache TTL ms
+        validatorConnectionAttemptDelay: 5, // Delay between validator connection attempts (ms)
+        bootstrapTimeout: 120_000, // time used (ms) to connect to new validators at bootstrap
+        writersShortCacheTTL: 2_000, // short TTL during bootstrap
+        writersLongCacheTTL: 120_000, // long TTL after bootstrap
+        maxValidators: 50,
+        maxWritersForAdminIndexerConnection: 10, // Connectivity constants
         disableRateLimit: false,
         enableErrorApplyLogs: false,
         enableInteractiveMode: true,
         enableRoleRequester: false,
         enableTxApplyLogs: false,
-        enableValidatorObserver: true,
         enableWallet: true,
-        maxValidators: 50,
         maxRetries: 3,
         messageThreshold: 3,
         messageValidatorRetryDelay: 1000, //How long to wait before retrying (ms) MESSAGE_VALIDATOR_RETRY_DELAY_MS
@@ -77,34 +95,45 @@ const configData = {
         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
+        maxPendingRequestsInPendingRequestsService: 50_000, // Maximum number of pending requests in PendingRequestService (This value should not exceed 256MB)
+        pendingRequestTimeout: 3000, // constant after which time the transaction will be considered invalid
+        txCommitTimeout: 2200,
+        txPoolSize: 1000, // size of transaction pool
+        validatorHealthCheckInterval: 5 * 60 * 1000, // How often to check validator health (ms)
         storesDirectory: 'stores/',
         storeName: 'mainnet',
     },
     [ENV.DEVELOPMENT]: {
+        debug: false,
         addressLength: 63,
         addressPrefix: TRAC_NETWORK_MSB_MAINNET_PREFIX,
         addressPrefixLength: TRAC_NETWORK_MSB_MAINNET_PREFIX.length,
         bech32mHrpLength: TRAC_NETWORK_MSB_MAINNET_PREFIX.length + 1, // len(addressPrefix + separator)
-        bootstrap: 'e90cca53847a12a82f3bf0f67401e45e2ccc1698ee163e61414c2894eb3c6b12',
+        bootstrap: '12f7f1668eac2e691e17cbc6a53e509c5cee78cdcac562313091c64e5fd077d6',
         channel: '12312313123123',
-        dhtBootstrap: ['116.202.214.149:10001', '157.180.12.214:10001', 'node1.hyperdht.org:49737', 'node2.hyperdht.org:49737', 'node3.hyperdht.org:49737'],
+        dhtBootstrap: ['116.202.214.149:10001','157.180.12.214:10001','node1.hyperdht.org:49737','node2.hyperdht.org:49737','node3.hyperdht.org:49737'],
         derivationPath: address.MAINNET_DERIVATION_PATH,
+        enableValidatorObserver: true,
+        pollInterval: 500, // Validator observer poll interval
+        adminCacheTTL: 60_000, // Admin cache TTL ms
+        validatorConnectionAttemptDelay: 5, // Delay between validator connection attempts (ms)
+        bootstrapTimeout: 30_000,  // time used (ms) to connect to new validators at bootstrap
+        writersShortCacheTTL: 1_000, // short TTL during bootstrap
+        writersLongCacheTTL: 2_000, // long TTL after bootstrap
+        maxValidators: 10,
+        maxWritersForAdminIndexerConnection: 10, // Connectivity constants
         disableRateLimit: false,
         enableErrorApplyLogs: true,
         enableInteractiveMode: true,
         enableRoleRequester: false,
         enableTxApplyLogs: true,
-        enableValidatorObserver: true,
         enableWallet: true,
-        maxValidators: 6,
-        maxRetries: 0,
+        maxRetries: 3,
         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;
@@ -115,18 +144,21 @@ const configData = {
         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/',
+        maxPendingRequestsInPendingRequestsService: 50_000, // Maximum number of pending requests in PendingRequestService (This value should not exceed 256MB)
+        pendingRequestTimeout: 3000, // constant after which time the transaction will be considered invalid
+        txCommitTimeout: 2200,
+        txPoolSize: 1000, // size of transaction pool
+        validatorHealthCheckInterval: 1_000, // How often to check validator health (ms)
+        storesDirectory: 'stores/',
         storeName: 'development',
     }
 }
 
 export const createConfig = (environment, options) => {
     return new Config(options, configData[environment])
-}
+}

package/src/core/network/Network.js

@@ -8,22 +8,17 @@ import NetworkMessages from './protocols/NetworkMessages.js';
 import { sleep } from '../../utils/helpers.js';
 import {
     TRAC_NAMESPACE,
-    NETWORK_MESSAGE_TYPES
+    EventType,
+    CONNECTION_STATUS
 } 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';
-import { networkMessageFactory } from '../../messages/network/v1/networkMessageFactory.js';
 import TransactionRateLimiterService from './services/TransactionRateLimiterService.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);
-    }
-};
+import PendingRequestService from './services/PendingRequestService.js';
+import TransactionCommitService from "./services/TransactionCommitService.js";
+import ValidatorHealthCheckService from './services/ValidatorHealthCheckService.js';
+import { Logger } from '../../utils/logger.js';
+import { WalletProvider } from 'trac-wallet';
 
 const wakeup = new w();
 
@@ -35,11 +30,15 @@ class Network extends ReadyResource {
     #validatorConnectionManager;
     #validatorMessageOrchestrator;
     #config;
-    #identityProvider = null;
     #pendingConnections;
     #connectTimeoutMs;
     #maxPendingConnections;
     #rateLimiter;
+    #pendingRequestsService;
+    #transactionCommitService;
+    #wallet;
+    #validatorHealthCheckService;
+    #logger;
 
     /**
      * @param {State} state
@@ -52,11 +51,13 @@ class Network extends ReadyResource {
         this.#connectTimeoutMs = config.connectTimeoutMs || 5000;
         this.#maxPendingConnections = config.maxPendingConnections || 50;
         this.#pendingConnections = new Map();
-        this.#transactionPoolService = new TransactionPoolService(state, address, this.#config);
+        this.#transactionCommitService = new TransactionCommitService(this.#config);
+        this.#transactionPoolService = new TransactionPoolService(state, address, this.#transactionCommitService ,this.#config);
         this.#validatorObserverService = new ValidatorObserverService(this, state, address, this.#config);
         this.#validatorConnectionManager = new ConnectionManager(this.#config);
         this.#validatorMessageOrchestrator = new MessageOrchestrator(this.#validatorConnectionManager, state, this.#config);
-
+        this.#pendingRequestsService = new PendingRequestService(this.#config);
+        this.#logger = new Logger(this.#config);
     }
 
     get swarm() {
@@ -80,7 +81,7 @@ class Network extends ReadyResource {
     }
 
     async _open() {
-        console.log('Network initialization...');
+        this.#logger.info('Network initialization...');
 
         this.setupNetworkListeners();
 
@@ -89,15 +90,19 @@ class Network extends ReadyResource {
     }
 
     async _close() {
-        // TODO: Implement better "await" logic for stopping services
-        console.log('Network: closing gracefully...');
-        this.transactionPoolService.stopPool();
+        this.#logger.info('Network: closing gracefully...');
+        await this.transactionPoolService.stopPool();
         await sleep(100);
-        this.#validatorObserverService.stopValidatorObserver();
+        await this.#validatorObserverService.stopValidatorObserver();
         await sleep(5_000);
+        if (this.#validatorHealthCheckService) {
+            await this.#validatorHealthCheckService.close();
+        }
 
         this.cleanupNetworkListeners();
         this.cleanupPendingConnections();
+        this.#pendingRequestsService.close();
+        this.#transactionCommitService.close();
 
         if (this.#swarm !== null) {
             this.#swarm.destroy();
@@ -105,23 +110,41 @@ class Network extends ReadyResource {
     }
 
     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.#logger.debug(`Network Event: VALIDATOR_CONNECTION_TIMEOUT | PublicKey: ${publicKey} | Type: ${type} | TimeoutMs: ${timeoutMs}`);
             this.#pendingConnections.delete(publicKey);
         });
 
-        // VALIDATOR_CONNECTION_READY
         this.on(EventType.VALIDATOR_CONNECTION_READY, async ({ publicKey, type, connection }) => {
-            debugLog(`Network Event: VALIDATOR_CONNECTION_READY | PublicKey: ${publicKey} | Type: ${type}`);
+            this.#logger.debug(`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') {
-                await connection.protocolSession.send(NETWORK_MESSAGE_TYPES.GET.VALIDATOR);
+                try {
+                    if (!connection.protocolSession.isProbed()) await connection.protocolSession.probe();
+                } catch (err) {
+                    this.#logger.debug(`failed to probe peer with publicKey ${publicKey}: ${err?.message ?? err}`);
+                }
+
+                this.#validatorConnectionManager.addValidator(publicKey, connection);
+
+                let healthCheckSupported = false;
+                try {
+                    healthCheckSupported = connection.protocolSession.isHealthCheckSupported();
+                } catch (err) {
+                    this.#logger.debug(`health check support unknown for peer with publicKey ${publicKey}: ${err?.message ?? err}`);
+                }
+
+                if (healthCheckSupported) {
+                    this.#validatorHealthCheckService.start(publicKey);
+                } else {
+                    this.#validatorHealthCheckService.stop(publicKey);
+                }
             }
 
         });
@@ -145,8 +168,10 @@ class Network extends ReadyResource {
         wallet,
     ) {
         if (!this.#swarm) {
-            const keyPair = await this.initializeNetworkingKeyPair(store, wallet);
-            const wrappedWallet = this.#getNetworkWalletWrapper(wallet, keyPair);
+            const { wallet: wrappedWallet, keyPair } = await this.#getOrGenerateWallet(store, wallet);
+            this.#wallet = wrappedWallet
+            this.#validatorMessageOrchestrator.setWallet(this.#wallet);
+
             this.#swarm = new Hyperswarm({
                 keyPair,
                 bootstrap: this.#config.dhtBootstrap,
@@ -159,14 +184,18 @@ class Network extends ReadyResource {
             this.#rateLimiter = new TransactionRateLimiterService(this.#swarm, this.#config);
             this.#networkMessages = new NetworkMessages(
                 state,
-                wrappedWallet,
+                this.#wallet,
                 this.#rateLimiter,
                 this.#transactionPoolService,
-                this.#validatorConnectionManager,
+                this.#pendingRequestsService,
+                this.#transactionCommitService,
                 this.#config
             );
+            this.#validatorHealthCheckService = new ValidatorHealthCheckService(this.#config);
+            await this.#validatorHealthCheckService.ready();
+            this.#validatorConnectionManager.subscribeToHealthChecks(this.#validatorHealthCheckService);
 
-            console.log(`Channel: ${b4a.toString(this.#config.channel)}`);
+            this.#logger.info(`Channel: ${b4a.toString(this.#config.channel)}`);
 
             this.#swarm.on('connection', async (connection) => {
                 // Per-peer connection initialization:
@@ -185,12 +214,20 @@ class Network extends ReadyResource {
                 }
 
                 connection.on('close', () => {
+                    this.#pendingRequestsService.rejectPendingRequestsForPeer(
+                        publicKey,
+                        new Error('Connection closed before response')
+                    );
                     this.#swarm.leavePeer(connection.remotePublicKey);
                     this.#validatorConnectionManager.remove(publicKey);
                     connection.protocolSession.close();
                 });
 
                 connection.on('error', (error) => {
+                    this.#pendingRequestsService.rejectPendingRequestsForPeer(
+                        publicKey,
+                        error ?? new Error('Connection error before response')
+                    );
                     if (
                         error && error.message && (
                             error.message.includes('connection reset by peer') ||
@@ -200,7 +237,7 @@ class Network extends ReadyResource {
                         // TODO: decide if we want to handle this error in a specific way. It generates a lot of logs.
                         return;
                     }
-                    console.error(error.message)
+                    this.#logger.error(error?.message ?? 'Unknown network connection error');
                 });
 
             });
@@ -218,22 +255,44 @@ class Network extends ReadyResource {
         return this.#pendingConnections.size;
     }
 
-    async initializeNetworkingKeyPair(store, wallet) {
+    disconnectValidatorPeer(publicKey, reason = 'validator peer invalidated') {
+        const publicKeyHex = this.#normalizePublicKey(publicKey);
+        if (!publicKeyHex) return false;
+
+        const hadPendingValidatorConnection = this.#clearPendingValidatorConnection(publicKeyHex);
+        const isTrackedValidator = this.#validatorConnectionManager.exists(publicKeyHex);
+
+        const shouldLeavePeer = hadPendingValidatorConnection || isTrackedValidator;
+
+        if (shouldLeavePeer && this.#swarm?.peers?.has(publicKeyHex)) {
+            this.#logger.debug(`Network.disconnectValidatorPeer: leaving peer ${publicKeyHex}. Reason: ${reason}`);
+            this.#swarm.leavePeer(b4a.from(publicKeyHex, 'hex'));
+        }
+
+        if (isTrackedValidator) {
+            this.#logger.debug(`Network.disconnectValidatorPeer: detaching tracked validator ${publicKeyHex}. Reason: ${reason}`);
+            this.#validatorConnectionManager.remove(publicKeyHex, { endConnection: false });
+        }
+
+        return hadPendingValidatorConnection || isTrackedValidator;
+    }
+
+    async #getOrGenerateWallet(store, wallet) {
         if (!this.#config.enableWallet) {
-            return await store.createKeyPair(TRAC_NAMESPACE);
+            const keyPair = await store.createKeyPair(TRAC_NAMESPACE);
+            const wallet = await new WalletProvider(this.#config).fromSecretKey(keyPair.secretKey)
+            return { keyPair, wallet }
         } else {
-            return {
-                publicKey: wallet.publicKey,
-                secretKey: wallet.secretKey
-            };
+            const keyPair = { publicKey: wallet.publicKey, secretKey: wallet.secretKey }
+            return { keyPair, wallet }
         }
     }
 
     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;
+            this.#logger.debug(`Network.tryConnect: Connection to peer: ${publicKey} as type: ${type} is already pending or max pending connections reached.`);
+            return CONNECTION_STATUS.IGNORED;
         }
 
         const timeoutId = setTimeout(() => {
@@ -250,35 +309,41 @@ class Network extends ReadyResource {
         const peerInfo = this.#swarm.peers.get(publicKey);
         if (peerInfo) {
             const connection = this.#swarm._allConnections.get(peerInfo.publicKey);
-            if (connection && connection.protocolSession) {
+
+            if (connection &&
+                connection.protocolSession &&
+                !this.#pendingRequestsService.isProbePending(connection.remotePublicKey.toString('hex'))
+            ) {
                 await this.#finalizeConnection(publicKey, type, connection);
+                return CONNECTION_STATUS.CONNECTED;
             }
         }
-    }
-
-    async isConnected(publicKey) {
-        return this.#swarm.peers.has(publicKey) &&
-            this.#swarm.peers.get(publicKey).connectedTime != -1
+        
+        return CONNECTION_STATUS.PENDING;
     }
 
     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}`);
+        this.#logger.debug(`Network.finalizeConnection: Connected to peer: ${publicKey} as type: ${type}`);
     }
 
-    #getNetworkWalletWrapper(wallet, keyPair) {
-        if (!this.#identityProvider) {
-            this.#identityProvider = NetworkWalletFactory.provide({
-                enableWallet: this.#config.enableWallet,
-                wallet,
-                keyPair,
-                networkPrefix: this.#config.addressPrefix
-            });
-        }
-        return this.#identityProvider;
+    #normalizePublicKey(publicKey) {
+        if (typeof publicKey === 'string') return publicKey;
+        if (b4a.isBuffer(publicKey)) return b4a.toString(publicKey, 'hex');
+        return null;
     }
 
+    #clearPendingValidatorConnection(publicKeyHex) {
+        if (!this.#pendingConnections.has(publicKeyHex)) return false;
+
+        const { timeoutId, type } = this.#pendingConnections.get(publicKeyHex);
+        if (type !== 'validator') return false;
+
+        clearTimeout(timeoutId);
+        this.#pendingConnections.delete(publicKeyHex);
+        return true;
+    }
 }
 
 export default Network;

package/src/core/network/protocols/LegacyProtocol.js

@@ -9,8 +9,8 @@ class LegacyProtocol extends ProtocolInterface {
     #config;
     #router;
 
-    constructor(router, connection, config) {
-        super(router, connection, config);
+    constructor(router, connection, pendingRequestServiceInstance = null, config) {
+        super(router, connection, pendingRequestServiceInstance, config);
         this.#config = config;
         this.#router = router;
         this.init(connection);
@@ -41,20 +41,30 @@ class LegacyProtocol extends ProtocolInterface {
         this.#session = this.#channel.addMessage({
             encoding: c.json,
             onmessage: async (incomingMessage) => {
-                try {
-                    if (typeof incomingMessage === 'object' || typeof incomingMessage === 'string') {
-                        await this.#router.route(incomingMessage, connection, this.#session);
-                    } else {
-                        throw new Error('NetworkMessages: Received message is undefined');
+                this.#router.route(incomingMessage, connection).catch((err) => {
+                    console.error(`LegacyProtocol: unhandled router error: ${err.message}`);
+                    try {
+                        connection.end();
+                    } catch {
                     }
-                } catch (error) {
-                    console.error(`NetworkMessages: Failed to handle incoming message: ${error.message}`);
-                }
+                });
             }
         });
     }
 
-    send(message) {
+    // TODO: Legacy protocol does not require encoding. Consider removing this method after refactoring v1 and the protocol interface
+    decode(message) {
+        // No-op for legacy protocol
+        return message;
+    }
+
+    async send(message) {
+        this.sendAndForget(message);
+        // TODO: Change 'null' to an appropriate response if needed in the future
+        return Promise.resolve(null); // This is to maintain consistency with the ProtocolInterface and v1 protocol.
+    }
+
+    sendAndForget(message) {
         this.#session.send(message);
     }
 

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

@@ -1,47 +1,68 @@
-
-import b4a from 'b4a';
 import NetworkMessageRouter from './legacy/NetworkMessageRouter.js';
 import NetworkMessageRouterV1 from './v1/NetworkMessageRouter.js';
 import ProtocolSession from './ProtocolSession.js';
 import LegacyProtocol from './LegacyProtocol.js';
 import V1Protocol from './V1Protocol.js';
+
 class NetworkMessages {
     #legacyMessageRouter;
     #v1MessageRouter;
     #config;
+    #wallet;
+    #pendingRequestsService;
 
-    /**
-     * @param {Config} config
-     **/
-    constructor(state, wallet, rateLimiterService, txPoolService, connectionManager, config) {
+    constructor(
+        state,
+        wallet,
+        rateLimiterService,
+        txPoolService,
+        pendingRequestsService,
+        transactionCommitService,
+        config
+    ) {
         this.#config = config;
-        this.#initializeMessageRouter(state, wallet, rateLimiterService, txPoolService, connectionManager);
-    }
-
-    #initializeMessageRouter(state, wallet, rateLimiterService, txPoolService, connectionManager) {
+        this.#wallet = wallet;
+        this.#pendingRequestsService = pendingRequestsService;
         this.#legacyMessageRouter = new NetworkMessageRouter(
             state,
             wallet,
             rateLimiterService,
             txPoolService,
-            connectionManager,
             this.#config
         );
-        this.#v1MessageRouter = new NetworkMessageRouterV1(this.#config);
+
+        this.#v1MessageRouter = new NetworkMessageRouterV1(
+            state,
+            wallet,
+            rateLimiterService,
+            txPoolService,
+            pendingRequestsService,
+            transactionCommitService,
+            this.#config
+        );
     }
 
     async setupProtomuxMessages(connection) {
         // Attach a Protomux instance to this Hyperswarm connection.
         // Protomux multiplexes multiple logical protocol channels over a single encrypted stream.
 
-        const legacyProtocol = new LegacyProtocol(this.#legacyMessageRouter, connection, this.#config);
-        const v1Protocol = new V1Protocol(this.#v1MessageRouter, connection, this.#config);
+        const legacyProtocol = new LegacyProtocol(
+            this.#legacyMessageRouter,
+            connection,
+            null,
+            this.#config
+        );
+
+        const v1Protocol = new V1Protocol(
+            this.#v1MessageRouter,
+            connection,
+            this.#pendingRequestsService,
+            this.#config
+        );
 
         // ProtocolSession is attached to the Hyperswarm connection so other parts of the system (e.g. tryConnect)
         // can send messages without knowing how Protomux was initialized.
-        const protocolSession = new ProtocolSession(legacyProtocol, v1Protocol);
-        connection.protocolSession = protocolSession;
-
+        connection.protocolSession = new ProtocolSession(legacyProtocol, v1Protocol, this.#wallet, this.#config);
     }
 }