trac-msb 0.2.7 → 0.2.9

package/src/core/network/Network.js

@@ -2,10 +2,9 @@ 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';
+import NetworkMessages from './protocols/NetworkMessages.js';
 import { sleep } from '../../utils/helpers.js';
 import {
     TRAC_NAMESPACE,
@@ -13,52 +12,61 @@ 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';
+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);
+    }
+};
+
 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;
+    #rateLimiter;
+
+    /**
+     * @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.admin_stream = null;
-        this.admin = null;
-        this.validator = null;
-        this.custom_stream = null;
-        this.custom_node = null;
+        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.#validatorConnectionManager = new ConnectionManager(this.#config);
+        this.#validatorMessageOrchestrator = new MessageOrchestrator(this.#validatorConnectionManager, state, this.#config);
+
     }
 
     get swarm() {
         return this.#swarm;
     }
 
-    get channel() {
-        return this.#channel;
-    }
-
     get transactionPoolService() {
         return this.#transactionPoolService;
     }
@@ -77,22 +85,64 @@ class Network extends ReadyResource {
 
     async _open() {
         console.log('Network initialization...');
+
+        this.setupNetworkListeners();
+
         this.transactionPoolService.start();
         this.validatorObserverService.start();
     }
 
     async _close() {
+        // TODO: Implement better "await" logic for stopping services
         console.log('Network: closing gracefully...');
         this.transactionPoolService.stopPool();
         await sleep(100);
         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, async ({ 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') {
+                await connection.protocolSession.send(NETWORK_MESSAGE_TYPES.GET.VALIDATOR);
+            }
+
+        });
+    }
+
+    cleanupNetworkListeners() {
+        this.removeAllListeners(EventType.VALIDATOR_CONNECTION_TIMEOUT);
+        this.removeAllListeners(EventType.VALIDATOR_CONNECTION_READY);
+    }
+
+    cleanupPendingConnections() {
+        for (const { timeoutId } of this.#pendingConnections.values()) {
+            clearTimeout(timeoutId);
+        }
+        this.#pendingConnections.clear();
+    }
+
     async replicate(
         state,
         store,
@@ -103,36 +153,45 @@ 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)}`);
-            this.#networkMessages.initializeMessageRouter(state, wrappedWallet);
+            this.#rateLimiter = new TransactionRateLimiterService(this.#swarm);
+            this.#networkMessages = new NetworkMessages(
+                state,
+                wrappedWallet,
+                this.#rateLimiter,
+                this.#transactionPoolService,
+                this.#validatorConnectionManager,
+                this.#config
+            );
+
+            console.log(`Channel: ${b4a.toString(this.#config.channel)}`);
 
             this.#swarm.on('connection', async (connection) => {
-                const { message_channel, message } = await this.#networkMessages.setupProtomuxMessages(connection);
-                connection.messenger = message;
+                // Per-peer connection initialization:
+                // - attach Protomux (legacy + v1 channels/messages)
+                // - attach connection.protocolSession (used later by tryConnect / orchestrators to send messages)
+                await this.#networkMessages.setupProtomuxMessages(connection);
 
                 // ATTENTION: Must be called AFTER the protomux init above
                 const stream = store.replicate(connection);
                 wakeup.addStream(stream);
 
-                connection.on('close', () => {
-                    if (this.admin_stream === connection) {
-                        this.admin_stream = null;
-                        this.admin = null;
-                    }
-
-                    if (this.custom_stream === connection) {
-                        this.custom_stream = null;
-                        this.custom_node = null;
-                    }
-                    try { message_channel.close() } catch (e) { }
+                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', () => {
+                    this.#swarm.leavePeer(connection.remotePublicKey);
+                    this.#validatorConnectionManager.remove(publicKey);
+                    connection.protocolSession.close();
                 });
 
                 connection.on('error', (error) => {
@@ -146,18 +205,25 @@ class Network extends ReadyResource {
                         return;
                     }
                     console.error(error.message)
-
                 });
 
             });
 
-            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 +235,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.protocolSession) {
+                await this.#finalizeConnection(publicKey, type, connection);
+            }
         }
-        await this.#sendRequestByType(stream, type);
     }
 
     async isConnected(publicKey) {
@@ -204,66 +265,19 @@ class Network extends ReadyResource {
             this.#swarm.peers.get(publicKey).connectedTime != -1
     }
 
-    async #sendRequestByType(stream, type) {
-        const waitFor = {
-            validator: () => this.validatorConnectionManager.connectionCount(),
-            admin: () => this.admin_stream,
-            node: () => this.custom_stream
-        }[type];
-
-        if (type === 'validator') {
-            await stream.messenger.send(NETWORK_MESSAGE_TYPES.GET.VALIDATOR);
-        } else if (type === 'admin') {
-            await stream.messenger.send(NETWORK_MESSAGE_TYPES.GET.ADMIN);
-        } else if (type === 'node') {
-            await stream.messenger.send(NETWORK_MESSAGE_TYPES.GET.NODE);
-        } else {
-            return;
-        }
-        await this.spinLock(() => !waitFor())
-    };
-
-    async spinLock(conditionFn, maxIterations = 1500, intervalMs = 10) {
-        let counter = 0;
-        while (conditionFn() && counter < maxIterations) {
-            await sleep(intervalMs);
-            counter++;
-        }
-    }
-
-    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)
-        }
+    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}`);
     }
 
     #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 {
+class NetworkWalletFactory {
     static provide(options = {}) {
         const {
-            enableWallet = true,
+            enableWallet,
             wallet,
             keyPair,
-            networkPrefix = TRAC_NETWORK_MSB_MAINNET_PREFIX
+            networkPrefix
         } = options;
 
         if (enableWallet) {
@@ -29,12 +28,12 @@ export class NetworkWalletFactory {
 // TODO: Once Wallet class in trac-wallet exposes a constructor/factory that accepts an existing keyPair
 // (e.g. Wallet.fromKeyPair({ publicKey, secretKey }, networkPrefix)), replace EphemeralWallet
 // with a thin wrapper around that functionality instead of duplicating signing/verification logic.
-class EphemeralWallet {
+export class EphemeralWallet {
     #publicKey;
     #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/protocols/LegacyProtocol.js

@@ -0,0 +1,67 @@
+import Protomux from 'protomux';
+import ProtocolInterface from './ProtocolInterface.js';
+import b4a from 'b4a';
+import c from 'compact-encoding';
+
+class LegacyProtocol extends ProtocolInterface {
+    #channel;
+    #session;
+    #config;
+    #router;
+
+    constructor(router, connection, config) {
+        super(router, connection, config);
+        this.#config = config;
+        this.#router = router;
+        this.init(connection);
+    }
+
+    get channel() {
+        return this.#channel;
+    }
+
+    get session() {
+        return this.#session;
+    }
+
+    init(connection) {
+        // TODO: Abstract in a separate function
+        const mux = Protomux.from(connection);
+        connection.userData = mux;
+
+        this.#channel = mux.createChannel({
+            protocol: b4a.toString(this.#config.channel, 'utf8'),
+            onopen() { },
+            onclose() { }
+        });
+
+        this.#channel.open();
+
+        // Todo: Abstract in a separate function
+        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');
+                    }
+                } catch (error) {
+                    console.error(`NetworkMessages: Failed to handle incoming message: ${error.message}`);
+                }
+            }
+        });
+    }
+
+    send(message) {
+        this.#session.send(message);
+    }
+
+    close() {
+        this.#channel.close();
+    }
+
+}
+
+export default LegacyProtocol;

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

@@ -0,0 +1,48 @@
+
+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;
+
+    /**
+     * @param {object} config
+     **/
+    constructor(state, wallet, rateLimiterService, txPoolService, connectionManager, config) {
+        this.#config = config;
+        this.#initializeMessageRouter(state, wallet, rateLimiterService, txPoolService, connectionManager);
+    }
+
+    #initializeMessageRouter(state, wallet, rateLimiterService, txPoolService, connectionManager) {
+        this.#legacyMessageRouter = new NetworkMessageRouter(
+            state,
+            wallet,
+            rateLimiterService,
+            txPoolService,
+            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, 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.
+        const protocolSession = new ProtocolSession(legacyProtocol, v1Protocol);
+        connection.protocolSession = protocolSession;
+
+    }
+}
+
+export default NetworkMessages;

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

@@ -0,0 +1,31 @@
+/**
+ * ProtocolInterface serves as a base class for all network protocol implementations.
+ * @interface
+ */
+
+class ProtocolInterface {
+    
+    // TODO: Refactor this so we don't need to pass a reference for the whole network instance
+    constructor(router, connection, config) {
+        if (new.target === ProtocolInterface) {
+            throw new Error('ProtocolInterface cannot be instantiated directly');
+        }
+    }
+
+    init(connection) {
+        // Abstract method. Need to be implemented by subclasses.
+        throw new Error('init() method must be implemented by subclass');
+    }
+
+    send(message) {
+        // Abstract method. Need to be implemented by subclasses.
+        throw new Error('send() 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');
+    }
+}
+
+export default ProtocolInterface;

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

@@ -0,0 +1,59 @@
+// 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.
+class ProtocolSession {
+    #legacyProtocol;
+    #v1Protocol;
+
+    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;
+    }
+
+    getLegacy() {
+        return this.#legacyProtocol;
+    }
+
+    getV1() {
+        return this.#v1Protocol;
+    }
+
+    get(protocol) {
+        if (protocol === 'legacy') return this.#legacyProtocol;
+        if (protocol === 'v1') return this.#v1Protocol;
+        return null;
+    }
+
+    has(protocol) {
+        return Boolean(this.get(protocol));
+    }
+
+    send(message) {
+        // TODO: Support v1 messages
+        this.#legacyProtocol.send(message);
+    }
+
+    close() {
+        if (this.#legacyProtocol) {
+            try {
+                this.#legacyProtocol.close();
+            } catch (e) {
+                console.error('Failed to close legacy channel:', e); // TODO: Think about throwing instead
+            }
+        }
+
+        if (this.#v1Protocol) {
+            try {
+                this.#v1Protocol.close();
+            } catch (e) {
+                console.error('Failed to close v1 channel:', e); // TODO: Think about throwing instead
+            }
+        }
+    }
+}
+
+export default ProtocolSession;

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

@@ -0,0 +1,64 @@
+import Protomux from 'protomux';
+import ProtocolInterface from './ProtocolInterface.js';
+import b4a from 'b4a';
+import c from 'compact-encoding';
+
+class V1Protocol extends ProtocolInterface {
+    #channel;
+    #session;
+    #config;
+    #router;
+
+    constructor(router, connection, config) {
+        super(router, connection, config);
+        this.#config = config;
+        this.#router = router;
+        this.init(connection);
+    }
+
+    get channel() {
+        return this.#channel;
+    }
+
+    get session() {
+        return this.#session;
+    }
+
+    init(connection) {
+        const mux = Protomux.from(connection);
+        connection.userData = mux;
+
+        this.#channel = mux.createChannel({
+            protocol: 'network/v1',
+            onopen() { },
+            onclose() { }
+        });
+
+        this.#channel.open();
+
+        this.#session = this.#channel.addMessage({
+            encoding: c.raw,
+            onmessage: async (incomingMessage) => {
+                try {
+                    if (b4a.isBuffer(incomingMessage)) {
+                        await this.#router.route(incomingMessage, connection, this.#session);
+                    } else {
+                        throw new Error('NetworkMessages: v1 message must be a buffer');
+                    }
+                } catch (error) {
+                    console.error(`NetworkMessages: Failed to handle incoming v1 message: ${error.message}`);
+                }
+            }
+        });
+    }
+
+    send(message) {
+        this.#session.send(message);
+    }
+
+    close() {
+        this.#channel.close();
+    }
+}
+
+export default V1Protocol;