trac-msb 0.2.9 → 0.2.11

package/src/config/env.js

@@ -1,4 +1,5 @@
-import { TRAC_NETWORK_MSB_MAINNET_PREFIX } from 'trac-wallet/constants.js';
+import { TRAC_NETWORK_MSB_MAINNET_PREFIX, TRAC_NETWORK_MSB_TESTNET1_PREFIX } from 'trac-wallet/constants.js';
+import { TRAC_NETWORK_TESTNET_ID, TRAC_NETWORK_MAINNET_ID } from 'trac-crypto-api/constants.js';
 import { Config } from './config.js';
 
 export const ENV = {
@@ -6,11 +7,52 @@ export const ENV = {
     DEVELOPMENT: 'development',
     TESTNET1: 'testnet1'
 }
-// TODO: CREATE TEST ENV CONFIG SIMILAR TO MAINNET AND USE IT IN TESTS.
-// TODO: CREATE TESTNET1 ENV CONFIG and update npm scripts to run node witn mainnet or testnet1.
 
 const configData = {
+    [ENV.TESTNET1]: {
+        debug: false,
+        addressLength: 67,
+        addressPrefix: TRAC_NETWORK_MSB_TESTNET1_PREFIX,
+        addressPrefixLength: TRAC_NETWORK_MSB_TESTNET1_PREFIX.length,
+        bech32mHrpLength: TRAC_NETWORK_MSB_TESTNET1_PREFIX.length + 1, // len(addressPrefix + separator)
+        bootstrap: 'a7c0c2cf8e4722129097f89b2a29a092f23d6268fcca3fd9570ba5b702b99b95',
+        channel: '1111trac1network1msb1testnet1111',
+        dhtBootstrap: ['116.202.214.149:10001', '157.180.12.214:10001', 'node1.hyperdht.org:49737', 'node2.hyperdht.org:49737', 'node3.hyperdht.org:49737'], // these are used to peer discovery
+        disableRateLimit: false,
+        enableErrorApplyLogs: true,
+        enableInteractiveMode: true,
+        enableRoleRequester: false,
+        enableTxApplyLogs: true,
+        enableValidatorObserver: true,
+        enableWallet: true,
+        maxValidators: 50,
+        maxRetries: 3,
+        messageThreshold: 3,
+        messageValidatorRetryDelay: 1000, //How long to wait before retrying (ms) MESSAGE_VALIDATOR_RETRY_DELAY_MS
+        messageValidatorResponseTimeout: 3 * 3 * 1000, //Overall timeout for sending a message (ms). This is 3 * maxRetries * messageValidatorRetryDelay;
+        host: 'localhost',
+        port: 5000,
+        networkId: TRAC_NETWORK_TESTNET_ID,
+        maxPeers: 64, // Connectivity constants
+        maxParallel: 64, // Connectivity constants
+        maxServerConnections: Infinity, // Connectivity constants
+        maxClientConnections: Infinity, // Connectivity constants
+        maxWritersForAdminIndexerConnection: 10, // Connectivity constants
+        processIntervalMs: 50, // Pool constants
+        transactionPoolSize: 1000, // Operation handler constants
+        rateLimitCleanupIntervalMs: 120_000, // Rate limiting constants
+        rateLimitConnectionTimeoutMs: 60_000, // Rate limiting constants
+        rateLimitMaxTransactionsPerSecond: 50, // Rate limiting constants
+        maxPendingRequestsInPendingRequestsService: 50_000, // Maximum number of pending requests in PendingRequestService (This value should not exceed 256MB)
+        pendingRequestTimeout: 3000, // constant after which time the transaction will be considered invalid
+        txCommitTimeout: 2200,
+        txPoolSize: 1000, // size of transaction pool
+        validatorHealthCheckInterval: 5 * 60 * 1000, // How often to check validator health (ms)
+        storesDirectory: 'stores/',
+        storeName: 'testnet',
+    },
     [ENV.MAINNET]: {
+        debug: false,
         addressLength: 63,
         addressPrefix: TRAC_NETWORK_MSB_MAINNET_PREFIX,
         addressPrefixLength: TRAC_NETWORK_MSB_MAINNET_PREFIX.length,
@@ -30,10 +72,29 @@ const configData = {
         messageThreshold: 3,
         messageValidatorRetryDelay: 1000, //How long to wait before retrying (ms) MESSAGE_VALIDATOR_RETRY_DELAY_MS
         messageValidatorResponseTimeout: 3 * 3 * 1000, //Overall timeout for sending a message (ms). This is 3 * maxRetries * messageValidatorRetryDelay;
-        networkId: 918,
+        host: 'localhost',
+        port: 5000,
+        networkId: TRAC_NETWORK_MAINNET_ID,
+        maxPeers: 64, // Connectivity constants
+        maxParallel: 64, // Connectivity constants
+        maxServerConnections: Infinity, // Connectivity constants
+        maxClientConnections: Infinity, // Connectivity constants
+        maxWritersForAdminIndexerConnection: 10, // Connectivity constants
+        processIntervalMs: 50, // Pool constants
+        transactionPoolSize: 1000, // Operation handler constants
+        rateLimitCleanupIntervalMs: 120_000, // Rate limiting constants
+        rateLimitConnectionTimeoutMs: 60_000, // Rate limiting constants
+        rateLimitMaxTransactionsPerSecond: 50, // Rate limiting constants
+        maxPendingRequestsInPendingRequestsService: 50_000, // Maximum number of pending requests in PendingRequestService (This value should not exceed 256MB)
+        pendingRequestTimeout: 3000, // constant after which time the transaction will be considered invalid
+        txCommitTimeout: 2200,
+        txPoolSize: 1000, // size of transaction pool
+        validatorHealthCheckInterval: 5 * 60 * 1000, // How often to check validator health (ms)
         storesDirectory: 'stores/',
+        storeName: 'mainnet',
     },
     [ENV.DEVELOPMENT]: {
+        debug: true,
         addressLength: 63,
         addressPrefix: TRAC_NETWORK_MSB_MAINNET_PREFIX,
         addressPrefixLength: TRAC_NETWORK_MSB_MAINNET_PREFIX.length,
@@ -49,12 +110,30 @@ const configData = {
         enableValidatorObserver: true,
         enableWallet: true,
         maxValidators: 6,
-        maxRetries: 0,
+        maxRetries: 3,
         messageThreshold: 1000,
         messageValidatorRetryDelay: 1000, //How long to wait before retrying (ms) MESSAGE_VALIDATOR_RETRY_DELAY_MS
         messageValidatorResponseTimeout: 3 * 3 * 1000, //Overall timeout for sending a message (ms). This is 3 * maxRetries * messageValidatorRetryDelay;
-        networkId: 918,
-        storesDirectory : 'stores/',
+        host: 'localhost',
+        port: 5000,
+        networkId: TRAC_NETWORK_TESTNET_ID,
+        maxPeers: 64, // Connectivity constants
+        maxParallel: 64, // Connectivity constants
+        maxServerConnections: Infinity, // Connectivity constants
+        maxClientConnections: Infinity, // Connectivity constants
+        maxWritersForAdminIndexerConnection: 10, // Connectivity constants
+        processIntervalMs: 50, // Pool constants
+        transactionPoolSize: 1000, // Operation handler constants
+        rateLimitCleanupIntervalMs: 120_000, // Rate limiting constants
+        rateLimitConnectionTimeoutMs: 60_000, // Rate limiting constants
+        rateLimitMaxTransactionsPerSecond: 50, // Rate limiting constants
+        maxPendingRequestsInPendingRequestsService: 50_000, // Maximum number of pending requests in PendingRequestService (This value should not exceed 256MB)
+        pendingRequestTimeout: 3000, // constant after which time the transaction will be considered invalid
+        txCommitTimeout: 2200,
+        txPoolSize: 1000, // size of transaction pool
+        validatorHealthCheckInterval: 5 * 60 * 1000, // How often to check validator health (ms)
+        storesDirectory: 'stores/',
+        storeName: 'development',
     }
 }
 

package/src/core/network/Network.js

@@ -8,26 +8,16 @@ 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
+    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();
 
@@ -44,10 +34,15 @@ class Network extends ReadyResource {
     #connectTimeoutMs;
     #maxPendingConnections;
     #rateLimiter;
+    #pendingRequestsService;
+    #transactionCommitService;
+    #wallet;
+    #validatorHealthCheckService;
+    #logger;
 
     /**
      * @param {State} state
-     * @param {object} config
+     * @param {Config} config
      * @param {string} address
      **/
     constructor(state, config, address = null) {
@@ -56,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() {
@@ -84,7 +81,7 @@ class Network extends ReadyResource {
     }
 
     async _open() {
-        console.log('Network initialization...');
+        this.#logger.info('Network initialization...');
 
         this.setupNetworkListeners();
 
@@ -93,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();
@@ -109,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);
+                }
             }
 
         });
@@ -150,27 +169,33 @@ 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,
-                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.#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:
@@ -189,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') ||
@@ -204,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');
                 });
 
             });
@@ -236,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;
         }
 
@@ -254,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 {object} 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');