trac-msb 0.2.8 → 0.2.10

package/src/core/network/Network.js

@@ -4,21 +4,18 @@ 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,
-    MAX_PEERS,
-    MAX_PARALLEL,
-    MAX_SERVER_CONNECTIONS,
-    MAX_CLIENT_CONNECTIONS,
     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;
@@ -42,10 +39,11 @@ class Network extends ReadyResource {
     #pendingConnections;
     #connectTimeoutMs;
     #maxPendingConnections;
+    #rateLimiter;
 
     /**
      * @param {State} state
-     * @param {object} config
+     * @param {Config} config
      * @param {string} address
      **/
     constructor(state, config, address = null) {
@@ -53,18 +51,12 @@ class Network extends ReadyResource {
         this.#config = config
         this.#connectTimeoutMs = config.connectTimeoutMs || 5000;
         this.#maxPendingConnections = config.maxPendingConnections || 50;
-
         this.#pendingConnections = new Map();
         this.#transactionPoolService = new TransactionPoolService(state, address, this.#config);
         this.#validatorObserverService = new ValidatorObserverService(this, state, address, this.#config);
-        this.#networkMessages = new NetworkMessages(this, this.#config);
         this.#validatorConnectionManager = new ConnectionManager(this.#config);
         this.#validatorMessageOrchestrator = new MessageOrchestrator(this.#validatorConnectionManager, state, this.#config);
-        this.admin_stream = null;
-        this.admin = null;
-        this.validator = null;
-        this.custom_stream = null;
-        this.custom_node = null;
+
     }
 
     get swarm() {
@@ -97,6 +89,7 @@ class Network extends ReadyResource {
     }
 
     async _close() {
+        // TODO: Implement better "await" logic for stopping services
         console.log('Network: closing gracefully...');
         this.transactionPoolService.stopPool();
         await sleep(100);
@@ -119,7 +112,7 @@ class Network extends ReadyResource {
         });
 
         // VALIDATOR_CONNECTION_READY
-        this.on(EventType.VALIDATOR_CONNECTION_READY, ({ publicKey, type, connection }) => {
+        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;
@@ -128,19 +121,15 @@ class Network extends ReadyResource {
             this.#pendingConnections.delete(publicKey);
 
             if (type === 'validator') {
-                const target = b4a.from(publicKey, 'hex');
-                this.#validatorConnectionManager.addValidator(target, connection);
-                this.#sendRequestByType(connection, type);
+                await connection.protocolSession.send(NETWORK_MESSAGE_TYPES.GET.VALIDATOR);
             }
+
         });
     }
 
     cleanupNetworkListeners() {
-        // connect:timeout
-        this.removeAllListeners('connect:timeout');
-
-        // connect:ready
-        this.removeAllListeners('connect:ready');
+        this.removeAllListeners(EventType.VALIDATOR_CONNECTION_TIMEOUT);
+        this.removeAllListeners(EventType.VALIDATOR_CONNECTION_READY);
     }
 
     cleanupPendingConnections() {
@@ -161,18 +150,29 @@ class Network extends ReadyResource {
             this.#swarm = new Hyperswarm({
                 keyPair,
                 bootstrap: this.#config.dhtBootstrap,
-                maxPeers: MAX_PEERS,
-                maxParallel: MAX_PARALLEL,
-                maxServerConnections: MAX_SERVER_CONNECTIONS,
-                maxClientConnections: MAX_CLIENT_CONNECTIONS
+                maxPeers: this.#config.maxPeers,
+                maxParallel: this.#config.maxParallel,
+                maxServerConnections: this.#config.maxServerConnections,
+                maxClientConnections: this.#config.maxClientConnections
             });
 
+            this.#rateLimiter = new TransactionRateLimiterService(this.#swarm, this.#config);
+            this.#networkMessages = new NetworkMessages(
+                state,
+                wrappedWallet,
+                this.#rateLimiter,
+                this.#transactionPoolService,
+                this.#validatorConnectionManager,
+                this.#config
+            );
+
             console.log(`Channel: ${b4a.toString(this.#config.channel)}`);
-            this.#networkMessages.initializeMessageRouter(state, wrappedWallet);
 
             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);
@@ -185,17 +185,9 @@ class Network extends ReadyResource {
                 }
 
                 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) { }
-
+                    this.#swarm.leavePeer(connection.remotePublicKey);
+                    this.#validatorConnectionManager.remove(publicKey);
+                    connection.protocolSession.close();
                 });
 
                 connection.on('error', (error) => {
@@ -209,7 +201,6 @@ class Network extends ReadyResource {
                         return;
                     }
                     console.error(error.message)
-
                 });
 
             });
@@ -259,7 +250,7 @@ class Network extends ReadyResource {
         const peerInfo = this.#swarm.peers.get(publicKey);
         if (peerInfo) {
             const connection = this.#swarm._allConnections.get(peerInfo.publicKey);
-            if (connection && connection.messenger) {
+            if (connection && connection.protocolSession) {
                 await this.#finalizeConnection(publicKey, type, connection);
             }
         }
@@ -276,33 +267,6 @@ class Network extends ReadyResource {
         debugLog(`Network.finalizeConnection: Connected to peer: ${publicKey} as type: ${type}`);
     }
 
-    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++;
-        }
-    }
-
     #getNetworkWalletWrapper(wallet, keyPair) {
         if (!this.#identityProvider) {
             this.#identityProvider = NetworkWalletFactory.provide({

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

@@ -1,7 +1,7 @@
 import PeerWallet from 'trac-wallet';
 import b4a from 'b4a';
 
-export class NetworkWalletFactory {
+class NetworkWalletFactory {
     static provide(options = {}) {
         const {
             enableWallet,
@@ -28,7 +28,7 @@ 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;

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 {Config} 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;

package/src/core/network/protocols/legacy/NetworkMessageRouter.js

@@ -0,0 +1,84 @@
+import b4a from "b4a";
+import GetRequestHandler from "./handlers/GetRequestHandler.js";
+import ResponseHandler from "./handlers/ResponseHandler.js";
+import RoleOperationHandler from "../shared/handlers/RoleOperationHandler.js";
+import SubnetworkOperationHandler from "../shared/handlers/SubnetworkOperationHandler.js";
+import TransferOperationHandler from "../shared/handlers/TransferOperationHandler.js";
+import { NETWORK_MESSAGE_TYPES } from '../../../../utils/constants.js';
+import * as operation from '../../../../utils/applyOperations.js';
+import State from "../../../state/State.js";
+import PeerWallet from "trac-wallet";
+
+class NetworkMessageRouter {
+    #handlers;
+    #config;
+
+    /**
+     * @param {State} state
+     * @param {PeerWallet} wallet
+     * @param {TransactionRateLimiterService} rateLimiterService
+     * @param {TransactionPoolService} txPoolService
+     * @param {ConnectionManager} connectionManager
+     * @param {Config} config
+     **/
+    constructor(state, wallet, rateLimiterService, txPoolService, connectionManager, config) {
+        this.#config = config;
+
+        this.#handlers = {
+            get: new GetRequestHandler(wallet, state),
+            response: new ResponseHandler(state, wallet, connectionManager, this.#config),
+            roleTransaction: new RoleOperationHandler(state, wallet, rateLimiterService, txPoolService, this.#config),
+            subNetworkTransaction: new SubnetworkOperationHandler(state, wallet, rateLimiterService, txPoolService, this.#config),
+            tracNetworkTransaction: new TransferOperationHandler(state, wallet, rateLimiterService, txPoolService, this.#config),
+        }
+    }
+
+    // NOTE: messageProtomux can be deleted, ad this is a session, and we can extract this from connection
+    async route(incomingMessage, connection, messageProtomux) {
+        const channelString = b4a.toString(this.#config.channel, 'utf8');
+        if (this.#isGetRequest(incomingMessage)) {
+            await this.#handlers.get.handle(incomingMessage, messageProtomux, connection, channelString);
+        }
+        else if (this.#isResponse(incomingMessage)) {
+            await this.#handlers.response.handle(incomingMessage, connection, channelString);
+        }
+        else if (this.#isRoleAccessOperation(incomingMessage)) {
+            await this.#handlers.roleTransaction.handle(incomingMessage, connection);
+        }
+        else if (this.#isSubnetworkOperation(incomingMessage)) {
+            await this.#handlers.subNetworkTransaction.handle(incomingMessage, connection);
+        }
+        else if (this.#isTransferOperation(incomingMessage)) {
+            await this.#handlers.tracNetworkTransaction.handle(incomingMessage, connection);
+        }
+        else {
+            throw new Error(`Failed to route message. Pubkey of requester is ${connection.remotePublicKey ? b4a.toString(connection.remotePublicKey, 'hex') : 'unknown'}`);
+        }
+
+    }
+
+    #isGetRequest(message) {
+        return Object.values(NETWORK_MESSAGE_TYPES.GET).includes(message);
+    }
+
+
+    #isResponse(message) {
+        return Object.values(NETWORK_MESSAGE_TYPES.RESPONSE).includes(message.op);
+    }
+
+    #isRoleAccessOperation(message) {
+        return operation.isRoleAccess(message.type)
+    }
+
+    #isSubnetworkOperation(message) {
+        return operation.isTransaction(message.type) ||
+            operation.isBootstrapDeployment(message.type)
+    }
+
+    #isTransferOperation(message) {
+        return operation.isTransfer(message.type)
+    }
+}
+
+
+export default NetworkMessageRouter;

package/src/core/network/protocols/legacy/handlers/GetRequestHandler.js

@@ -0,0 +1,53 @@
+import { NETWORK_MESSAGE_TYPES } from '../../../../../utils/constants.js';
+import PeerWallet from 'trac-wallet';
+import b4a from 'b4a';
+
+class GetRequestHandler {
+    #wallet;
+    #state;
+
+    constructor(wallet, state) {
+        this.#wallet = wallet;
+        this.#state = state;
+    }
+
+    get state() {
+        return this.#state;
+    }
+
+    async handle(message, messageProtomux, connection, channelString) {
+        switch (message) {
+            case NETWORK_MESSAGE_TYPES.GET.VALIDATOR:
+                await this.handleGetValidatorResponse(messageProtomux, connection, channelString);
+                break;
+            default:
+                throw new Error(`Unhandled GET type: ${message}`);
+        }
+    }
+
+    async handleGetValidatorResponse(messageProtomux, connection, channelString) {
+        const nonce = PeerWallet.generateNonce().toString('hex');
+        const payload = {
+            op: 'validatorResponse',
+            wk: this.state.writingKey.toString('hex'),
+            address: this.#wallet.address,
+            nonce: nonce,
+            channel: channelString,
+            issuer: connection.remotePublicKey.toString('hex'),
+            timestamp: Date.now(),
+        };
+
+
+        const hashInput = b4a.from(JSON.stringify(payload), 'utf8');
+        const hash = await PeerWallet.blake3(hashInput);
+        const sig = this.#wallet.sign(hash);
+
+        const responseMessage = {
+            ...payload,
+            sig: sig.toString('hex'),
+        };
+        messageProtomux.send(responseMessage);
+    }
+}
+
+export default GetRequestHandler;

package/src/core/network/protocols/legacy/handlers/ResponseHandler.js

@@ -0,0 +1,37 @@
+import ValidatorResponse from '../validators/ValidatorResponse.js';
+import PeerWallet from 'trac-wallet';
+
+class ResponseHandler {
+    #responseValidator;
+    #connectionManager;
+
+    
+    constructor(state, wallet, connectionManager ,config) {
+        this.#responseValidator = new ValidatorResponse(state, wallet, config);
+        this.#connectionManager = connectionManager;
+
+    }
+
+    async handle(message, connection, channelString) {
+        await this.#handleValidatorResponse(message, connection, channelString);
+    }
+
+    async #handleValidatorResponse(message, connection, channelString) {
+        const isValid = await this.#responseValidator.validate(message, channelString);
+        if (isValid) {
+            const validatorAddressString = message.address;
+            const validatorPublicKey = PeerWallet.decodeBech32m(validatorAddressString);
+
+            if (this.#connectionManager.connected(validatorPublicKey)) {
+                return;
+                // TODO: What we should return? Or maybe we should throw?
+            }
+
+            this.#connectionManager.addValidator(validatorPublicKey, connection)
+        } else {
+            throw new Error("Validator response verification failed");
+        }
+    }
+}
+
+export default ResponseHandler;