trac-msb 0.2.13 → 0.2.15

package/src/core/network/Network.js

@@ -8,16 +8,22 @@ import NetworkMessages from './protocols/NetworkMessages.js';
 import { sleep } from '../../utils/helpers.js';
 import {
     TRAC_NAMESPACE,
-    EventType
+    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';
+import { networkMessageFactory } from '../../messages/network/v1/networkMessageFactory.js';
 import TransactionRateLimiterService from './services/TransactionRateLimiterService.js';
-import PendingRequestService from './services/PendingRequestService.js';
-import TransactionCommitService from "./services/TransactionCommitService.js";
-import ValidatorHealthCheckService from './services/ValidatorHealthCheckService.js';
-import { Logger } from '../../utils/logger.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();
 
@@ -34,11 +40,6 @@ class Network extends ReadyResource {
     #connectTimeoutMs;
     #maxPendingConnections;
     #rateLimiter;
-    #pendingRequestsService;
-    #transactionCommitService;
-    #wallet;
-    #validatorHealthCheckService;
-    #logger;
 
     /**
      * @param {State} state
@@ -51,13 +52,11 @@ class Network extends ReadyResource {
         this.#connectTimeoutMs = config.connectTimeoutMs || 5000;
         this.#maxPendingConnections = config.maxPendingConnections || 50;
         this.#pendingConnections = new Map();
-        this.#transactionCommitService = new TransactionCommitService(this.#config);
-        this.#transactionPoolService = new TransactionPoolService(state, address, this.#transactionCommitService ,this.#config);
+        this.#transactionPoolService = new TransactionPoolService(state, address, 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() {
@@ -81,7 +80,7 @@ class Network extends ReadyResource {
     }
 
     async _open() {
-        this.#logger.info('Network initialization...');
+        console.log('Network initialization...');
 
         this.setupNetworkListeners();
 
@@ -90,19 +89,15 @@ class Network extends ReadyResource {
     }
 
     async _close() {
-        this.#logger.info('Network: closing gracefully...');
-        await this.transactionPoolService.stopPool();
+        // TODO: Implement better "await" logic for stopping services
+        console.log('Network: closing gracefully...');
+        this.transactionPoolService.stopPool();
         await sleep(100);
-        await this.#validatorObserverService.stopValidatorObserver();
+        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();
@@ -110,41 +105,23 @@ class Network extends ReadyResource {
     }
 
     setupNetworkListeners() {
+        // VALIDATOR_CONNECTION_TIMEOUT
         this.on(EventType.VALIDATOR_CONNECTION_TIMEOUT, ({ publicKey, type, timeoutMs }) => {
-            this.#logger.debug(`Network Event: VALIDATOR_CONNECTION_TIMEOUT | PublicKey: ${publicKey} | Type: ${type} | TimeoutMs: ${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, async ({ publicKey, type, connection }) => {
-            this.#logger.debug(`Network Event: VALIDATOR_CONNECTION_READY | PublicKey: ${publicKey} | Type: ${type}`);
+            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') {
-                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);
-                }
+                await connection.protocolSession.send(NETWORK_MESSAGE_TYPES.GET.VALIDATOR);
             }
 
         });
@@ -169,9 +146,7 @@ class Network extends ReadyResource {
     ) {
         if (!this.#swarm) {
             const keyPair = await this.initializeNetworkingKeyPair(store, wallet);
-            this.#wallet = this.#getNetworkWalletWrapper(wallet, keyPair);
-            this.#validatorMessageOrchestrator.setWallet(this.#wallet);
-
+            const wrappedWallet = this.#getNetworkWalletWrapper(wallet, keyPair);
             this.#swarm = new Hyperswarm({
                 keyPair,
                 bootstrap: this.#config.dhtBootstrap,
@@ -184,18 +159,14 @@ class Network extends ReadyResource {
             this.#rateLimiter = new TransactionRateLimiterService(this.#swarm, this.#config);
             this.#networkMessages = new NetworkMessages(
                 state,
-                this.#wallet,
+                wrappedWallet,
                 this.#rateLimiter,
                 this.#transactionPoolService,
-                this.#pendingRequestsService,
-                this.#transactionCommitService,
+                this.#validatorConnectionManager,
                 this.#config
             );
-            this.#validatorHealthCheckService = new ValidatorHealthCheckService(this.#config);
-            await this.#validatorHealthCheckService.ready();
-            this.#validatorConnectionManager.subscribeToHealthChecks(this.#validatorHealthCheckService);
 
-            this.#logger.info(`Channel: ${b4a.toString(this.#config.channel)}`);
+            console.log(`Channel: ${b4a.toString(this.#config.channel)}`);
 
             this.#swarm.on('connection', async (connection) => {
                 // Per-peer connection initialization:
@@ -214,20 +185,12 @@ 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') ||
@@ -237,7 +200,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;
                     }
-                    this.#logger.error(error?.message ?? 'Unknown network connection error');
+                    console.error(error.message)
                 });
 
             });
@@ -269,7 +232,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) {
-            this.#logger.debug(`Network.tryConnect: Connection to peer: ${publicKey} as type: ${type} is already pending or max pending connections reached.`);
+            debugLog(`Network.tryConnect: Connection to peer: ${publicKey} as type: ${type} is already pending or max pending connections reached.`);
             return;
         }
 
@@ -287,21 +250,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 &&
-                !connection.protocolSession.isProbed() &&
-                !this.#pendingRequestsService.isProbePending(connection.remotePublicKey.toString('hex'))
-            ) {
+            if (connection && connection.protocolSession) {
                 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 });
-        this.#logger.debug(`Network.finalizeConnection: Connected to peer: ${publicKey} as type: ${type}`);
+        debugLog(`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, pendingRequestServiceInstance = null, config) {
-        super(router, connection, pendingRequestServiceInstance, config);
+    constructor(router, connection, config) {
+        super(router, connection, config);
         this.#config = config;
         this.#router = router;
         this.init(connection);
@@ -41,30 +41,20 @@ class LegacyProtocol extends ProtocolInterface {
         this.#session = this.#channel.addMessage({
             encoding: c.json,
             onmessage: async (incomingMessage) => {
-                this.#router.route(incomingMessage, connection).catch((err) => {
-                    console.error(`LegacyProtocol: unhandled router error: ${err.message}`);
-                    try {
-                        connection.end();
-                    } catch {
+                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');
                     }
-                });
+                } catch (error) {
+                    console.error(`NetworkMessages: Failed to handle incoming message: ${error.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) {
+    send(message) {
         this.#session.send(message);
     }
 

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

@@ -1,68 +1,47 @@
+
+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;
 
-    constructor(
-        state,
-        wallet,
-        rateLimiterService,
-        txPoolService,
-        pendingRequestsService,
-        transactionCommitService,
-        config
-    ) {
+    /**
+     * @param {Config} config
+     **/
+    constructor(state, wallet, rateLimiterService, txPoolService, connectionManager, config) {
         this.#config = config;
-        this.#wallet = wallet;
-        this.#pendingRequestsService = pendingRequestsService;
-        this.#legacyMessageRouter = new NetworkMessageRouter(
-            state,
-            wallet,
-            rateLimiterService,
-            txPoolService,
-            this.#config
-        );
+        this.#initializeMessageRouter(state, wallet, rateLimiterService, txPoolService, connectionManager);
+    }
 
-        this.#v1MessageRouter = new NetworkMessageRouterV1(
+    #initializeMessageRouter(state, wallet, rateLimiterService, txPoolService, connectionManager) {
+        this.#legacyMessageRouter = new NetworkMessageRouter(
             state,
             wallet,
             rateLimiterService,
             txPoolService,
-            pendingRequestsService,
-            transactionCommitService,
+            connectionManager,
             this.#config
         );
+        this.#v1MessageRouter = new NetworkMessageRouterV1(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,
-            null,
-            this.#config
-        );
-
-        const v1Protocol = new V1Protocol(
-            this.#v1MessageRouter,
-            connection,
-            this.#pendingRequestsService,
-            this.#config
-        );
+        const legacyProtocol = new LegacyProtocol(this.#legacyMessageRouter, connection, this.#config);
+        const v1Protocol = new V1Protocol(this.#v1MessageRouter, connection, 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.
-        connection.protocolSession = new ProtocolSession(legacyProtocol, v1Protocol, this.#wallet, this.#config);
+        const protocolSession = new ProtocolSession(legacyProtocol, v1Protocol);
+        connection.protocolSession = protocolSession;
+
     }
 }
 

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, pendingRequestService, config) {
+    constructor(router, connection, config) {
         if (new.target === ProtocolInterface) {
             throw new Error('ProtocolInterface cannot be instantiated directly');
         }
@@ -17,23 +17,11 @@ class ProtocolInterface {
         throw new Error('init() method must be implemented by subclass');
     }
 
-    // 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) {
+    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,158 +1,40 @@
-// ProtocolSession is a per-peer (per Hyperswarm connection) bridge that exposes the available
+// ProtocolSession is a per-peer (per Hyperswarm connection) wrapper 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, wallet, config) {
+    constructor(legacyProtocol, v1Protocol) {
         // 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);
     }
 
-    get preferredProtocol() {
-        return this.#preferredProtocol;
+    getLegacy() {
+        return this.#legacyProtocol;
     }
 
-    get supportedProtocols() {
-        return this.#supportedProtocols;
+    getV1() {
+        return this.#v1Protocol;
     }
 
-    isProbed() {
-        return this.#preferredProtocol !== null;
+    get(protocol) {
+        if (protocol === 'legacy') return this.#legacyProtocol;
+        if (protocol === 'v1') return this.#v1Protocol;
+        return null;
     }
 
-    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');
+    has(protocol) {
+        return Boolean(this.get(protocol));
     }
 
-    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);
+    send(message) {
+        // TODO: Support v1 messages
+        this.#legacyProtocol.send(message);
     }
 
     close() {
@@ -160,7 +42,7 @@ class ProtocolSession {
             try {
                 this.#legacyProtocol.close();
             } catch (e) {
-                this.#logger.error(`ProtocolSession: failed to close legacy channel: ${e?.message ?? e}`); // TODO: Think about throwing instead
+                console.error('Failed to close legacy channel:', e); // TODO: Think about throwing instead
             }
         }
 
@@ -168,19 +50,10 @@ class ProtocolSession {
             try {
                 this.#v1Protocol.close();
             } catch (e) {
-                this.#logger.error(`ProtocolSession: failed to close v1 channel: ${e?.message ?? e}`); // TODO: Think about throwing instead
+                console.error('Failed to close v1 channel:', 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;