trac-msb 0.2.17 → 0.2.19

package/src/core/network/services/TransactionPoolService.js

@@ -1,37 +1,79 @@
 // PoolService.js
 import { BATCH_SIZE } from '../../../utils/constants.js';
 import Scheduler from '../../../utils/Scheduler.js';
+import Denque from "denque";
+import b4a from "b4a";
+
+export class TransactionPoolProofUnavailableError extends Error {
+    constructor(txHash, blockNumber, reason = 'unknown', timestamp = 0) {
+        const timestampValue = timestamp instanceof Date ? timestamp.getTime() : timestamp;
+        const safeTimestamp = Number.isSafeInteger(timestampValue) ? timestampValue : 0;
+        super(`Proof unavailable for txHash ${txHash} at block ${blockNumber} at ${safeTimestamp}. Reason: ${reason}`);
+        this.txHash = txHash;
+        this.blockNumber = blockNumber;
+        this.timestamp = safeTimestamp;
+        this.reason = reason;
+    }
+}
+
+export class TransactionPoolMissingCommitReceiptError extends Error {
+    constructor(txHash) {
+        super(`Missing commit receipt for txHash ${txHash}`);
+        this.txHash = txHash;
+    }
+}
+
+export class TransactionPoolInvalidIncomingDataError extends Error {
+    constructor(message = 'Invalid transaction pool incoming data') {
+        super(message);
+    }
+}
+
+export class TransactionPoolFullError extends Error {
+    constructor(maxSize) {
+        super(`Transaction pool is full. Maximum size of ${maxSize} reached.`);
+        this.maxSize = maxSize
+    }
+
+}
+
+export class TransactionPoolAlreadyQueuedError extends Error {
+    constructor(txHash) {
+        super(`Transaction with hash ${txHash} is already queued in the transaction pool.`);
+    }
+}
 
 class TransactionPoolService {
     #state;
     #address;
     #config;
-    #tx_pool = [];
+    #txPool = new Denque();
+    #transactionCommitService
     #scheduler = null;
+    #queuedTxHashes
 
     /**
      * @param {State} state
      * @param {string} address
+     * @param {TransactionCommitService} transactionCommitService
      * @param {Config} config
      **/
-    constructor(state, address, config) {
+    constructor(state, address, transactionCommitService, config) {
         this.#state = state;
         this.#address = address;
+        this.#transactionCommitService = transactionCommitService;
+        this.#queuedTxHashes = new Set(); // to improve lookup performance when checking for duplicate transactions
         this.#config = config;
     }
 
-    get tx_pool() {
-        return this.#tx_pool;
+    get txPool() {
+        return this.#txPool;
     }
 
     get state() {
         return this.#state;
     }
 
-    get address() {
-        return this.#address;
-    }
-
     async start() {
         if (!this.#config.enableWallet) {
             console.info('TransactionPoolService can not start. Wallet is not enabled');
@@ -49,7 +91,7 @@ class TransactionPoolService {
     async #worker(next) {
         try {
             await this.#processTransactions();
-            if (this.#tx_pool.length > 0) {
+            if (this.#txPool.size() > 0) {
                 next(0);
             } else {
                 next(this.#config.processIntervalMs);
@@ -65,35 +107,104 @@ class TransactionPoolService {
 
     async #processTransactions() {
         const canValidate = await this.#checkValidationPermissions();
-        if (canValidate && this.#tx_pool.length > 0) {
-            const batch = this.#prepareBatch();
-            await this.#state.append(batch);
+        if (!canValidate || this.#txPool.size() === 0) return;
+
+        const batchItems = this.#prepareBatch();
+        const encodedBatch = batchItems.map(item => item.encodedTx);
+        const batchTxHashes = batchItems.map(item => item.txHash);
+        try {
+            const receipts = await this.#state.appendWithProofOfPublication(encodedBatch, batchTxHashes);
+
+            const receiptsByHash = new Map();
+            for (const receipt of receipts) {
+                if (receipt.txHash) receiptsByHash.set(receipt.txHash, receipt);
+            }
+
+            for (const item of batchItems) {
+                const receipt = receiptsByHash.get(item.txHash);
+
+                if (!receipt) {
+                    this.#transactionCommitService.rejectPendingCommit(
+                        item.txHash,
+                        new TransactionPoolMissingCommitReceiptError(item.txHash)
+                    );
+                    continue;
+                }
+
+                if (!receipt.proof) {
+                    this.#transactionCommitService.rejectPendingCommit(
+                        item.txHash,
+                        new TransactionPoolProofUnavailableError(
+                            item.txHash,
+                            receipt.blockNumber,
+                            receipt.proofError,
+                            receipt.timestamp
+                        )
+                    );
+                    continue;
+                }
+
+                this.#transactionCommitService.resolvePendingCommit(item.txHash, receipt);
+            }
+        } catch (error) {
+            for (const item of batchItems) {
+                this.#transactionCommitService.rejectPendingCommit(item.txHash, error);
+            }
+            console.error(
+                `TransactionPoolService: failed to process batch (size=${batchItems.length}): ${error?.message ?? 'unknown error'}`
+            );
         }
     }
 
     async #checkValidationPermissions() {
         const isAdminAllowedToValidate = await this.state.isAdminAllowedToValidate();
-        const isNodeAllowedToValidate = await this.state.allowedToValidate(this.address);
+        const isNodeAllowedToValidate = await this.state.allowedToValidate(this.#address);
         return isNodeAllowedToValidate || isAdminAllowedToValidate;
     }
 
     #prepareBatch() {
-        const length = Math.min(this.tx_pool.length, BATCH_SIZE);
-        const batch = this.tx_pool.slice(0, length);
-        this.tx_pool.splice(0, length);
+        const batch = [];
+        const batchSize = Math.min(this.#txPool.size(), BATCH_SIZE);
+
+        for (let i = 0; i < batchSize; i++) {
+            const tx = this.#txPool.shift();
+            this.#queuedTxHashes.delete(tx.txHash);
+            batch.push(tx);
+        }
         return batch;
     }
 
-    addTransaction(tx) {
-        this.tx_pool.push(tx);
+    addTransaction(txHash, encodedTx) {
+        this.validateEnqueue();
+        if (!txHash || !encodedTx || typeof txHash !== 'string' || !b4a.isBuffer(encodedTx)) {
+            throw new TransactionPoolInvalidIncomingDataError()
+        }
+        if (this.hasTransaction(txHash)) {
+            throw new TransactionPoolAlreadyQueuedError(txHash);
+        }
+        this.#queuedTxHashes.add(txHash);
+        const txData = { txHash, encodedTx };
+        this.txPool.push(txData);
     }
 
     async stopPool(waitForCurrent = true) {
         if (!this.#scheduler) return;
         await this.#scheduler.stop(waitForCurrent);
         this.#scheduler = null;
+        this.#queuedTxHashes.clear();
+        this.#txPool.clear();
         console.info('TransactionPoolService: closing gracefully...');
     }
+
+    validateEnqueue() {
+        if (this.#txPool.size() >= this.#config.txPoolSize) {
+            throw new TransactionPoolFullError(this.#config.txPoolSize);
+        }
+    }
+
+    hasTransaction(txHash) {
+        return this.#queuedTxHashes.has(txHash);
+    }
 }
 
 export default TransactionPoolService;

package/src/core/network/services/TransactionRateLimiterService.js

@@ -1,4 +1,7 @@
 import b4a from 'b4a';
+import {V1ProtocolError} from "../protocols/v1/V1ProtocolError.js";
+import {ResultCode} from "../../../utils/constants.js";
+import {publicKeyToAddress} from "../../../utils/helpers.js";
 
 class TransactionRateLimiterService {
     #lastCleanup;
@@ -14,19 +17,23 @@ class TransactionRateLimiterService {
     }
 
     /*
-        Checks if the peer has exceeded the rate limit.
+        Checks if the peer has exceeded the rate limit for the current 1-second window.
         A peer is considered to have exceeded the rate limit if:
-        - The time since the last activity is greater than or equal to 1000 ms (1 second)
-        - The number of transactions in the current session is greater than or equal to rateLimitMaxTransactionsPerSecond
-        If the rate limit is exceeded, the peer is disconnected.
+        - The request belongs to the same 1-second window as previous requests (tracked per peer)
+        - The number of transactions already seen in this window is >= rateLimitMaxTransactionsPerSecond
+
+        Important:
+        - This method assumes the caller increments transactionCount AFTER calling this method.
+          (So exactly rateLimitMaxTransactionsPerSecond are allowed; the next one is blocked.)
     */
-    #hasExceededRateLimit(peer) {
+    #hasExceededRateLimit(peer, currentTime) {
         const peerData = this.#connectionsStatistics.get(peer);
-        const currentSecond = Math.floor((peerData.lastActivityTime - peerData.sessionStartTime) / 1000);
-        
-        if (currentSecond > Math.floor((peerData.lastCounterReset - peerData.sessionStartTime) / 1000)) {
+        const currentSecond = Math.floor((currentTime - peerData.sessionStartTime) / 1000);
+        const lastResetSecond = Math.floor((peerData.lastCounterReset - peerData.sessionStartTime) / 1000);
+
+        if (currentSecond > lastResetSecond) {
             peerData.transactionCount = 0;
-            peerData.lastCounterReset = peerData.lastActivityTime;
+            peerData.lastCounterReset = currentTime;
             this.#connectionsStatistics.set(peer, peerData);
         }
         
@@ -34,23 +41,18 @@ class TransactionRateLimiterService {
     }
 
     /*
-        Handles the rate limiting for a peer connection.
-        If the peer has exceeded the rate limit, it disconnects the peer.
-        Otherwise, it updates the connection info with the current timestamp.
+        Handles rate limiting for a peer connection (legacy protocol).
+        If the peer has exceeded the rate limit, it disconnects the peer and returns true.
+        Otherwise, it updates the connection info with the current timestamp and returns false.
     */
-    handleRateLimit(connection) {
+    legacyHandleRateLimit(connection) {
         const peer = b4a.toString(connection.remotePublicKey, 'hex');
         const currentTime = Date.now();
 
         this.#cleanUpOldConnections(currentTime);
         this.#initializePeerConnectionInfoEntry(peer, currentTime);
 
-        if (this.#isConnectionExpired(peer)) {
-            this.#connectionsStatistics.delete(peer);
-            return false;
-        }
-
-        if (this.#hasExceededRateLimit(peer)) {
+        if (this.#hasExceededRateLimit(peer, currentTime)) {
             console.warn(`Rate limit exceeded for peer ${peer}. Disconnecting...`);
             this.#swarm.leavePeer(connection.remotePublicKey);
             connection.end();
@@ -61,23 +63,42 @@ class TransactionRateLimiterService {
         return false;
     }
 
+    /*
+        Handles rate limiting for a peer connection (v1 protocol).
+        If the peer has exceeded the rate limit, it throws V1ProtocolError with RATE_LIMITED result code.
+        Otherwise, it updates the connection info with the current timestamp.
+    */
+    v1HandleRateLimit(connection) {
+        const peer = b4a.toString(connection.remotePublicKey, 'hex');
+        const currentTime = Date.now();
+
+        this.#cleanUpOldConnections(currentTime);
+        this.#initializePeerConnectionInfoEntry(peer, currentTime);
+
+        if (this.#hasExceededRateLimit(peer, currentTime)) {
+            throw new V1ProtocolError(
+                ResultCode.RATE_LIMITED,
+                `Rate limit exceeded for peer ${publicKeyToAddress(connection.remotePublicKey, this.#config)}`
+            );
+        }
+        this.#updatePeerConnectionInfo(peer, currentTime);
+    }
+
     #shouldCleanupConnections(currentTime) {
         return currentTime - this.#lastCleanup >= this.#config.rateLimitCleanupIntervalMs;
     }
 
     /**
-        Cleans up old connections that have timed out.
-        Condition for cleanup based on #shouldCleanupConnections:
-        - If the last cleanup was more than rateLimitCleanupIntervalMs ago
+        Cleans up per-peer statistics that have been inactive for more than rateLimitCleanupIntervalMs.
+        Runs at most once every rateLimitCleanupIntervalMs.
     */
     #cleanUpOldConnections(currentTime) {
         if (!this.#shouldCleanupConnections(currentTime)) {
             return;
         }
 
-        for (const [peer, _] of this.#connectionsStatistics.entries()) {
-            if (this.#isConnectionExpired(peer)) {
-                //console.log(`Connection for peer ${peer} has expired. Removing...`);
+        for (const [peer] of this.#connectionsStatistics.entries()) {
+            if (this.#isConnectionExpired(peer, currentTime)) {
                 this.#connectionsStatistics.delete(peer);
             }
         }
@@ -87,19 +108,19 @@ class TransactionRateLimiterService {
 
     /*
         Initializes the connection statistics for a peer.
-        Connection is a HashMap with the following structure:
-            peerPublicKey: {
-                sessionStartTime: timestamp,     // When the external peer started their session
-                lastActivityTime: timestamp,     // Timestamp of peer's most recent activity (default: 0)
-                transactionCount: number         // Number of transactions in the current session (default: 0)
+        Stored as a HashMap with the following structure:
+            peerPublicKeyHex: {
+                sessionStartTime: timestamp,  // When we first saw this peer (start of local tracking session)
+                lastActivityTime: timestamp,  // Timestamp of peer's most recent activity
+                lastCounterReset: timestamp,  // Timestamp when the per-second counter was last reset
+                transactionCount: number      // Transactions seen in the current 1-second window
             }
-        
     */
     #initializePeerConnectionInfoEntry(peer, timestamp) {
         if (!this.#connectionsStatistics.has(peer)) {
             this.#connectionsStatistics.set(peer, {
                 sessionStartTime: timestamp,
-                lastActivityTime: 0,
+                lastActivityTime: timestamp,
                 lastCounterReset: timestamp,
                 transactionCount: 0
             });
@@ -118,11 +139,12 @@ class TransactionRateLimiterService {
     }
 
     /*
-        Checks if the connection for a peer has expired.
+        Checks if the stored statistics for a peer have expired due to inactivity.
+        Note: this is NOT a network-level connection timeout; it's only used to evict old Map entries.
     */
-    #isConnectionExpired(peer) {
+    #isConnectionExpired(peer, currentTime) {
         const peerData = this.#connectionsStatistics.get(peer);
-        return peerData.lastActivityTime - peerData.sessionStartTime >= this.#config.rateLimitConnectionTimeoutMs;
+        return currentTime - peerData.lastActivityTime >= this.#config.rateLimitConnectionTimeoutMs;
     }
 }
 

package/src/core/network/services/ValidatorHealthCheckService.js

@@ -0,0 +1,127 @@
+import ReadyResource from 'ready-resource';
+import b4a from 'b4a';
+import { generateUUID } from '../../../utils/helpers.js';
+import { EventType } from '../../../utils/constants.js';
+import { Logger } from '../../../utils/logger.js';
+
+const DEFAULT_HEALTH_CHECK_INTERVAL_MS = 300000; // 5 minutes
+class ValidatorHealthCheckService extends ReadyResource {
+    #config;
+    #intervalMs;
+    #timers;
+    #logger;
+
+    /**
+     * @param {object} config
+     */
+    constructor(config = {}) {
+        super();
+        this.#config = config;
+        this.#timers = new Map();
+        this.#logger = new Logger(config);
+
+        const interval = this.#config.validatorHealthCheckInterval;
+        this.#intervalMs = interval ? this.#checkInterval(interval) : DEFAULT_HEALTH_CHECK_INTERVAL_MS;
+
+        this.#logger.debug(`initialized with intervalMs ${this.#intervalMs}`);
+    }
+
+    get size() {
+        return this.#timers.size;
+    }
+
+    async _open() {
+        this.#logger.debug('open: health check service ready');
+    }
+
+    async _close() {
+        this.#logger.debug('close: stopping all health checks');
+        this.#stopAll();
+        this.#timers.clear();
+    }
+
+    /**
+     * Start periodic health checks for a validator.
+     * @param {String} publicKey
+     */
+    start(publicKey) {
+        if (!this.opened) {
+            throw new Error('start: service not ready. Call ready() before start().');
+        }
+        const publicKeyHex = this.#normalizePublicKey(publicKey);
+        if (this.#timers.has(publicKeyHex)) {
+            this.#logger.debug(`start: already scheduled for ${publicKey}`);
+            return false; // TODO: Implement better error handling
+        }
+
+        const timerId = setInterval(() => {
+            this.#emitHealthCheck(publicKeyHex);
+        }, this.#intervalMs);
+
+        this.#timers.set(publicKeyHex, { timerId, intervalMs: this.#intervalMs });
+        this.#logger.debug(`start: scheduled health checks for ${publicKeyHex} every ${this.#intervalMs} ms`);
+
+        return true;
+    }
+
+    /**
+     * Stop periodic health checks for a validator.
+     * @param {String} publicKey
+     * @returns {boolean} true if stopped, false if not scheduled
+     */
+    stop(publicKey) {
+        const publicKeyHex = this.#normalizePublicKey(publicKey);
+        const entry = this.#timers.get(publicKeyHex);
+        if (!entry) {
+            this.#logger.debug(`stop: did not find scheduled health check for public key ${publicKey}. Aborting`);
+            return false;
+        }
+        clearInterval(entry.timerId);
+        this.#timers.delete(publicKeyHex);
+        this.#logger.debug(`stop: cancelled health checks for ${publicKeyHex}`);
+        return true;
+    }
+
+    /**
+     * Check if a validator is scheduled.
+     * @param {String} publicKey
+     * @returns {boolean}
+     */
+    has(publicKey) {
+        return this.#timers.has(this.#normalizePublicKey(publicKey));
+    }
+
+    async #emitHealthCheck(publicKey) {
+        try {
+            const requestId = generateUUID();
+            this.emit(EventType.VALIDATOR_HEALTH_CHECK, publicKey, requestId);
+            this.#logger.debug(`Emitted health check event for ${publicKey} with requestId ${requestId}`);
+        } catch (error) {
+            this.#logger.error(`ValidatorHealthCheckService: Failed to emit health check for ${publicKey}: ${error?.message || error}`);
+        }
+    }
+
+    #stopAll() {
+        this.#logger.debug(`stopAll: cancelling health checks for ${this.#timers.size} validators`);
+        for (const publicKey of this.#timers.keys()) {
+            this.stop(publicKey);
+        }
+    }
+
+    #checkInterval(intervalMs) {
+        const ms = Number(intervalMs);
+        if (!Number.isFinite(ms) || ms <= 0) {
+            throw new RangeError(`ValidatorHealthCheckService: invalid intervalMs value: ${intervalMs}`);
+        }
+        return ms;
+    }
+
+    // TODO: This method is used in multiple places. Consider moving it to a utility file or exposing it from PeerWallet.
+    #normalizePublicKey(publicKey) {
+        if (b4a.isBuffer(publicKey)) return publicKey.toString('hex');
+        if (typeof publicKey === 'string') return publicKey.toLowerCase();
+        throw new TypeError('ValidatorHealthCheckService: publicKey must be a Buffer or hex string');
+    }
+}
+
+export default ValidatorHealthCheckService;