trac-msb 0.2.15 → 0.2.16

package/src/core/network/Network.js

@@ -8,22 +8,16 @@ import NetworkMessages from './protocols/NetworkMessages.js';
 import { sleep } from '../../utils/helpers.js';
 import {
     TRAC_NAMESPACE,
-    NETWORK_MESSAGE_TYPES
+    EventType
 } 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';
 
 const wakeup = new w();
 
@@ -40,6 +34,11 @@ class Network extends ReadyResource {
     #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 {
+                    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);
+                }
             }
 
         });
@@ -146,7 +169,9 @@ class Network extends ReadyResource {
     ) {
         if (!this.#swarm) {
             const keyPair = await this.initializeNetworkingKeyPair(store, wallet);
-            const wrappedWallet = this.#getNetworkWalletWrapper(wallet, keyPair);
+            this.#wallet = this.#getNetworkWalletWrapper(wallet, keyPair);
+            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');
                 });
 
             });
@@ -232,7 +269,7 @@ 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.`);
+            this.#logger.debug(`Network.tryConnect: Connection to peer: ${publicKey} as type: ${type} is already pending or max pending connections reached.`);
             return;
         }
 
@@ -250,21 +287,21 @@ 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 &&
+                !connection.protocolSession.isProbed() &&
+                !this.#pendingRequestsService.isProbePending(connection.remotePublicKey.toString('hex'))
+            ) {
                 await this.#finalizeConnection(publicKey, type, connection);
             }
         }
     }
 
-    async isConnected(publicKey) {
-        return this.#swarm.peers.has(publicKey) &&
-            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}`);
+        this.#logger.debug(`Network.finalizeConnection: Connected to peer: ${publicKey} as type: ${type}`);
     }
 
     #getNetworkWalletWrapper(wallet, keyPair) {

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);
     }
 }
 

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

@@ -6,7 +6,7 @@
 class ProtocolInterface {
     
     // TODO: Refactor this so we don't need to pass a reference for the whole network instance
-    constructor(router, connection, config) {
+    constructor(router, connection, pendingRequestService, config) {
         if (new.target === ProtocolInterface) {
             throw new Error('ProtocolInterface cannot be instantiated directly');
         }
@@ -17,11 +17,23 @@ class ProtocolInterface {
         throw new Error('init() method must be implemented by subclass');
     }
 
-    send(message) {
+    // TODO: This method is only kept here because of v1, but it should be probably removed from the interface
+    // Remove it after we finish refactoring v1 protocol
+    decode(message) {
+        // Abstract method. Need to be implemented by subclasses.
+        throw new Error('decode() method must be implemented by subclass');
+    }
+
+    async send(message) {
         // Abstract method. Need to be implemented by subclasses.
         throw new Error('send() method must be implemented by subclass');
     }
 
+    sendAndForget(message) {
+        // Abstract method. Need to be implemented by subclasses.
+        throw new Error('sendAndForget() method must be implemented by subclass');
+    }
+
     close() {
         // Abstract method. Need to be implemented by subclasses.
         throw new Error('close() method must be implemented by subclass');

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

@@ -1,40 +1,158 @@
-// ProtocolSession is a per-peer (per Hyperswarm connection) wrapper that exposes the available
+// ProtocolSession is a per-peer (per Hyperswarm connection) bridge that exposes the available
 // protocol messengers (legacy JSON, v1 binary) in one place.
 //
 // Why it exists:
 // - `setupProtomuxMessages(connection)` creates Protomux channels/messages for a specific peer.
+
+import { networkMessageFactory } from '../../../messages/network/v1/networkMessageFactory.js';
+import { generateUUID } from '../../../utils/helpers.js';
+import { NETWORK_CAPABILITIES, ResultCode } from '../../../utils/constants.js';
+import { Logger } from '../../../utils/logger.js';
+
 class ProtocolSession {
     #legacyProtocol;
     #v1Protocol;
+    #preferredProtocol = null;
+    #activeProtocol = null;
+    #supportedProtocols = {
+        LEGACY: 'legacy',
+        V1: 'v1'
+    }
+    #wallet;
+    #config;
+    #capabilities;
+    #logger;
 
-    constructor(legacyProtocol, v1Protocol) {
+    constructor(legacyProtocol, v1Protocol, wallet, config) {
         // These are Protomux "message" objects (returned by channel.addMessage).
         // They are connection-scoped and expose .send(...), already wired to the channel's encoding.
         this.#legacyProtocol = legacyProtocol;
         this.#v1Protocol = v1Protocol;
+
+        this.#activeProtocol = this.#v1Protocol;
+        this.#wallet = wallet;
+        this.#config = config;
+        this.#capabilities = NETWORK_CAPABILITIES;
+        this.#logger = new Logger(config);
     }
 
-    getLegacy() {
-        return this.#legacyProtocol;
+    get preferredProtocol() {
+        return this.#preferredProtocol;
     }
 
-    getV1() {
-        return this.#v1Protocol;
+    get supportedProtocols() {
+        return this.#supportedProtocols;
     }
 
-    get(protocol) {
-        if (protocol === 'legacy') return this.#legacyProtocol;
-        if (protocol === 'v1') return this.#v1Protocol;
-        return null;
+    isProbed() {
+        return this.#preferredProtocol !== null;
     }
 
-    has(protocol) {
-        return Boolean(this.get(protocol));
+    setLegacyAsPreferredProtocol() {
+        if (this.isProbed()) {
+            // TODO:  SOMETIMES WE ARE PROBING NODE FOR MULTIPLE AMOUNT OF TIME, THIS IS BAD. WE NEED TO INVESTIGATE THIS.
+            //this.#logger.warn(`ProtocolSession: preferred protocol is already set and cannot be changed to LEGACY. Current preferred protocol: ${this.#preferredProtocol}`);
+            return;
+        }
+        this.#preferredProtocol = this.#supportedProtocols.LEGACY;
+        this.#activeProtocol = this.#legacyProtocol;
+        this.#logger.debug('ProtocolSession: set preferred protocol to LEGACY');
     }
 
-    send(message) {
-        // TODO: Support v1 messages
-        this.#legacyProtocol.send(message);
+    setV1AsPreferredProtocol() {
+        if (this.isProbed()) {
+            // TODO:  SOMETIMES WE ARE PROBING NODE FOR MULTIPLE AMOUNT OF TIME, THIS IS BAD. WE NEED TO INVESTIGATE THIS.
+            //this.#logger.warn(`ProtocolSession: preferred protocol is already set and cannot be changed to V1. Current preferred protocol: ${this.#preferredProtocol}`);
+            return;
+        }
+
+        this.#preferredProtocol = this.#supportedProtocols.V1;
+        this.#activeProtocol = this.#v1Protocol;
+        this.#logger.debug('ProtocolSession: set preferred protocol to V1');
+    }
+
+    /**
+    * Probes the peer to determine which protocol version they support/prefer. 
+    * This is needed to know if the connected peer supports the new v1 protocol
+    * or if we should fall back to legacy for this connection.
+    * 
+    * TODO: After legacy protocol is retired, we can remove the concept of "probing" and just use v1 directly.
+    * For now, this is needed to determine which protocol to use for health checks.
+    * A good future improvement would be to implement a more robust negotiation mechanism that doesn't rely on timeouts
+    * (e.g. peer sends a "hello" message indicating supported protocol versions right after connection is established).
+    */
+    async probe() {
+        if (this.isProbed()) {
+            this.#logger.warn(`ProtocolSession: preferred protocol is already set. Skipping probe. Current preferred protocol: ${this.#preferredProtocol}`);
+            return; // TODO: Consider not returning silently
+        }
+
+        try {
+            const message = await this.#buildLivenessRequest();
+            if (!this.#v1Protocol) {
+                throw new Error('ProtocolSession: v1 protocol not available for probing');
+            }
+            const result = await this.#v1Protocol.send(message);
+            if (result !== ResultCode.OK) {
+                // TODO: Think about how to handle failure result codes after legacy protocol is retired
+                this.#logger.warn(`ProtocolSession: v1 protocol probe failed with non-OK result code: ${result}`);
+                this.setLegacyAsPreferredProtocol();
+                return;
+            }
+            this.setV1AsPreferredProtocol();
+        } catch (err) {
+            this.#logger.debug(`ProtocolSession: v1 protocol probe failed, falling back to legacy. Details: ${err?.message ?? err}`);
+            this.setLegacyAsPreferredProtocol();
+        }
+    }
+
+    /**
+     * Sends a single health check message to a peer.
+     * This is used by the ValidatorHealthCheckService.
+     * @returns {Promise<ResultCode>} Result code indicating success or failure of the health check.
+     */
+    async sendHealthCheck() {
+        switch (this.#preferredProtocol) {
+            case this.#supportedProtocols.V1:
+                try {
+                    const message = await this.#buildLivenessRequest();
+                    return await this.#v1Protocol.send(message);
+                }
+                catch (err) {
+                    this.#logger.error(`ProtocolSession: v1 health check failed: ${err?.message ?? err}`);
+                    return ResultCode.UNEXPECTED_ERROR; // TODO: Consider just propagating the error instead
+                }
+            case this.#supportedProtocols.LEGACY:
+                this.#logger.warn('ProtocolSession: health check not supported on LEGACY protocol');
+                return ResultCode.OK; // TODO: Consider implementing a new result code (e.g. NOT_SUPPORTED) instead of returning OK
+            default:
+                this.#logger.warn('ProtocolSession: preferred protocol not set. Call probe() first.');
+                return ResultCode.UNSPECIFIED; // TODO: Define a more specific result code.
+        }
+    }
+
+    /**
+     * Tells whether the connected peer supports health checks, which is a feature of the v1 protocol.
+     * @returns {Boolean} True if health checks are supported in the preferred protocol, false otherwise.
+     */
+    isHealthCheckSupported() {
+        if (this.#preferredProtocol === null) {
+            throw new Error('ProtocolSession: preferred protocol not set. Call probe() first.');
+        }
+        return this.#preferredProtocol === this.#supportedProtocols.V1;
+    }
+
+    // TODO: Consider moving this method to be used only in V1 internally, just like 'encode'
+    decode(message) {
+        return this.#activeProtocol.decode(message);
+    }
+
+    async send(message) {
+        return this.#activeProtocol.send(message);
+    }
+
+    sendAndForget(message) {
+        this.#activeProtocol.sendAndForget(message);
     }
 
     close() {
@@ -42,7 +160,7 @@ class ProtocolSession {
             try {
                 this.#legacyProtocol.close();
             } catch (e) {
-                console.error('Failed to close legacy channel:', e); // TODO: Think about throwing instead
+                this.#logger.error(`ProtocolSession: failed to close legacy channel: ${e?.message ?? e}`); // TODO: Think about throwing instead
             }
         }
 
@@ -50,10 +168,19 @@ class ProtocolSession {
             try {
                 this.#v1Protocol.close();
             } catch (e) {
-                console.error('Failed to close v1 channel:', e); // TODO: Think about throwing instead
+                this.#logger.error(`ProtocolSession: failed to close v1 channel: ${e?.message ?? e}`); // TODO: Think about throwing instead
             }
         }
     }
+
+    async #buildLivenessRequest() {
+        if (!this.#wallet || !this.#config) {
+            throw new Error('ProtocolSession: wallet/config not set for liveness request');
+        }
+        const requestId = generateUUID();
+        return await networkMessageFactory(this.#wallet, this.#config)
+            .buildLivenessRequest(requestId, this.#capabilities);
+    }
 }
 
 export default ProtocolSession;