trac-msb 0.2.9 → 0.2.11

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

@@ -0,0 +1,172 @@
+import {NetworkOperationType, ResultCode} from '../../../utils/constants.js';
+import {isHexString} from '../../../utils/helpers.js';
+import {V1ProtocolError, V1TimeoutError, V1UnexpectedError} from "../protocols/v1/V1ProtocolError.js";
+import {Config} from '../../../config/config.js';
+import b4a from 'b4a';
+
+const PEER_PUBLIC_KEY_HEX_LENGTH = 64;
+
+class PendingRequestService {
+    #pendingRequests;
+    #requestMessageTypes = [NetworkOperationType.LIVENESS_REQUEST, NetworkOperationType.BROADCAST_TRANSACTION_REQUEST];
+    #config;
+
+    constructor(config) {
+        this.#pendingRequests = new Map(); // Map<id, pendingRequestEntry>
+        this.#config = config;
+    }
+
+    has(id) {
+        return this.#pendingRequests.has(id);
+    }
+
+    isProbePending(peerPubKeyHex) {
+        for (const [, entry] of this.#pendingRequests) {
+            if (entry.requestedTo === peerPubKeyHex && entry.requestType === NetworkOperationType.LIVENESS_REQUEST) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    #validateRegisterInput(peerPubKeyHex, message) {
+        if (!isHexString(peerPubKeyHex) || peerPubKeyHex.length !== PEER_PUBLIC_KEY_HEX_LENGTH) {
+            throw new Error('Invalid peer public key. Expected 32-byte hex string.');
+        }
+
+        if (!message || typeof message !== 'object') {
+            throw new Error('Pending request message must be an object.');
+        }
+
+        if (typeof message.id !== 'string' || message.id.length === 0) {
+            throw new Error('Pending request ID must be a non-empty string.');
+        }
+
+        if (!this.#requestMessageTypes.includes(message.type)) {
+            throw new Error('Unsupported pending request type.');
+        }
+    }
+
+    /*
+    @returns {Promise}
+    */
+    registerPendingRequest(peerPubKeyHex, message) {
+        this.#validateRegisterInput(peerPubKeyHex, message);
+        const id = message.id;
+        if (this.#pendingRequests.size >= this.#config.maxPendingRequestsInPendingRequestsService) {
+            throw new Error('Maximum number of pending requests reached.');
+        }
+
+        if (this.#pendingRequests.has(id)) {
+            throw new Error(`Pending request with ID ${id} from peer ${peerPubKeyHex} already exists.`);
+        }
+
+        const entry = {
+            id: id,
+            requestType: message.type,
+            requestTxData: this.#extractRequestTxData(message),
+            requestedTo: peerPubKeyHex,
+            timeoutMs: this.#config.pendingRequestTimeout,
+            timeoutId: null,
+            resolve: null,
+            reject: null,
+        }
+
+        const promise = new Promise((resolve, reject) => {
+            entry.resolve = resolve;
+            entry.reject = reject;
+        });
+
+        entry.timeoutId = setTimeout(() => {
+            this.rejectPendingRequest(
+                id,
+                new V1TimeoutError(
+                    `Pending request with ID ${id} from peer ${peerPubKeyHex} timed out after ${entry.timeoutMs} ms.`,
+                    true
+                ));
+
+        }, entry.timeoutMs);
+
+        this.#pendingRequests.set(id, entry);
+        return promise;
+    }
+
+    #extractRequestTxData(message) {
+        if (message.type !== NetworkOperationType.BROADCAST_TRANSACTION_REQUEST) return null;
+        const txData = message.broadcast_transaction_request?.data;
+        return b4a.isBuffer(txData) ? txData : null;
+    }
+
+    getAndDeletePendingRequest(id) {
+        const entry = this.#pendingRequests.get(id);
+        if (!entry) return null;
+
+        clearTimeout(entry.timeoutId);
+        this.#pendingRequests.delete(id);
+        return entry;
+    }
+
+    getPendingRequest(id) {
+        const entry = this.#pendingRequests.get(id);
+        if (!entry) return null;
+        return entry;
+    }
+
+    // for now, we are resolving only resultCode, but we can extend it in the future if needed...
+    resolvePendingRequest(id, resultCode = ResultCode.OK) {
+        const entry = this.getAndDeletePendingRequest(id);
+        if (!entry) return false;
+        entry.resolve(resultCode);
+        return true;
+    }
+
+    rejectPendingRequest(id, error) {
+        const entry = this.getAndDeletePendingRequest(id);
+        if (!entry) return false;
+        const err = error instanceof V1ProtocolError
+            ? error
+            : new V1UnexpectedError(error?.message ?? 'Unexpected error');
+        entry.reject(err);
+        return true;
+    }
+
+    rejectPendingRequestsForPeer(peerPubKeyHex, error) {
+        const idsToReject = [];
+        for (const [id, entry] of this.#pendingRequests) {
+            if (entry.requestedTo === peerPubKeyHex) idsToReject.push(id);
+        }
+
+        for (const id of idsToReject) {
+            this.rejectPendingRequest(id, error);
+        }
+
+        return idsToReject.length;
+    }
+
+    stopPendingRequestTimeout(id) {
+        const entry = this.#pendingRequests.get(id);
+        if (!entry) return false;
+
+        clearTimeout(entry.timeoutId);
+        entry.timeoutId = null;
+        return true;
+    }
+
+    close() {
+        for (const [id, entry] of this.#pendingRequests) {
+            clearTimeout(entry.timeoutId);
+            try {
+                entry.reject(
+                    new V1UnexpectedError(
+                        `Pending request ${id} cancelled (shutdown).`,
+                        false)
+                );
+            } catch (error) {
+                console.error(`PendingRequestService.close: failed to reject pending request ${id}:`, error);
+            }
+        }
+        this.#pendingRequests.clear();
+    }
+}
+
+export default PendingRequestService;

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

@@ -0,0 +1,149 @@
+import {isHexString} from '../../../utils/helpers.js';
+import {TRANSACTION_COMMIT_SERVICE_BUFFER_SIZE} from '../../../utils/constants.js';
+
+const TX_HASH_HEX_STRING_LENGTH = 64;
+
+class TransactionCommitService {
+    #pendingCommits;
+    #config;
+
+    constructor(config) {
+        this.#pendingCommits = new Map(); // Map<txHash, pendingCommitEntry>
+        this.#config = config;
+    }
+
+    #assertTxHash(txHash) {
+        if (!isHexString(txHash) || txHash.length !== TX_HASH_HEX_STRING_LENGTH) {
+            throw new PendingCommitInvalidTxHashError(txHash);
+        }
+    }
+
+    has(txHash) {
+        this.#assertTxHash(txHash);
+        return this.#pendingCommits.has(txHash);
+    }
+
+    /*
+        @returns {Promise}
+    */
+    registerPendingCommit(txHash) {
+        this.#assertTxHash(txHash);
+
+        if (this.#pendingCommits.size >= TRANSACTION_COMMIT_SERVICE_BUFFER_SIZE) {
+            throw new PendingCommitBufferFullError(TRANSACTION_COMMIT_SERVICE_BUFFER_SIZE);
+        }
+
+        if (this.#pendingCommits.has(txHash)) {
+            throw new PendingCommitAlreadyExistsError(txHash);
+        }
+
+        const timeoutMs = this.#config.txCommitTimeout;
+
+        const entry = {
+            txHash,
+            timeoutMs,
+            timeoutId: null,
+            resolve: null,
+            reject: null,
+        };
+
+        const promise = new Promise((resolve, reject) => {
+            entry.resolve = resolve;
+            entry.reject = reject;
+        });
+
+        entry.timeoutId = setTimeout(() => {
+            this.rejectPendingCommit(
+                txHash,
+                new PendingCommitTimeoutError(txHash, timeoutMs)
+            );
+        }, timeoutMs);
+
+        this.#pendingCommits.set(txHash, entry);
+        return promise;
+    }
+
+    getAndDeletePendingCommit(txHash) {
+        this.#assertTxHash(txHash);
+        const entry = this.#pendingCommits.get(txHash);
+        if (!entry) return null;
+
+        clearTimeout(entry.timeoutId);
+        this.#pendingCommits.delete(txHash);
+        return entry;
+    }
+
+    resolvePendingCommit(txHash, receipt = null) {
+        this.#assertTxHash(txHash);
+        const entry = this.getAndDeletePendingCommit(txHash);
+        if (!entry) return false;
+        entry.resolve(receipt);
+        return true;
+    }
+
+    rejectPendingCommit(txHash, error) {
+        this.#assertTxHash(txHash);
+        const entry = this.getAndDeletePendingCommit(txHash);
+        if (!entry) return false;
+
+        entry.reject(
+            error instanceof Error
+                ? error
+                : new PendingCommitUnexpectedError('Unexpected commit error')
+        );
+
+        return true;
+    }
+
+    close() {
+        for (const [txHash, entry] of this.#pendingCommits) {
+            clearTimeout(entry.timeoutId);
+            try {
+                entry.reject(
+                    new PendingCommitCancelledError(txHash)
+                );
+            } catch (error) {
+                console.error(`TransactionCommitService.close: failed to reject pending commit ${txHash}:`, error);
+            }
+        }
+        this.#pendingCommits.clear();
+    }
+}
+
+export default TransactionCommitService;
+
+export class PendingCommitInvalidTxHashError extends Error {
+    constructor(txHash) {
+        super(`Invalid txHash format: ${txHash}`);
+    }
+}
+
+export class PendingCommitBufferFullError extends Error {
+    constructor(limit) {
+        super(`Maximum number of pending commits reached (limit=${limit}).`);
+    }
+}
+
+export class PendingCommitAlreadyExistsError extends Error {
+    constructor(txHash) {
+        super(`Pending commit for txHash ${txHash} already exists.`);
+    }
+}
+
+export class PendingCommitTimeoutError extends Error {
+    constructor(txHash, timeoutMs) {
+        super(`Pending commit for txHash ${txHash} timed out after ${timeoutMs} ms.`);
+    }
+}
+
+export class PendingCommitCancelledError extends Error {
+    constructor(txHash) {
+        super(`Pending commit ${txHash} cancelled (shutdown).`);
+    }
+}
+
+export class PendingCommitUnexpectedError extends Error {
+    constructor(message = 'Unexpected commit error') {
+        super(message);
+    }
+}

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

@@ -1,37 +1,40 @@
 // PoolService.js
-import { BATCH_SIZE, PROCESS_INTERVAL_MS } from '../../../utils/constants.js';
+import { BATCH_SIZE } from '../../../utils/constants.js';
 import Scheduler from '../../../utils/Scheduler.js';
+import Denque from "denque";
+import b4a from "b4a";
 
 class TransactionPoolService {
     #state;
     #address;
     #config;
-    #tx_pool = [];
+    #txPool = new Denque();
+    #transactionCommitService
     #scheduler = null;
+    #queuedTxHashes
 
     /**
      * @param {State} state
      * @param {string} address
-     * @param {object} config
+     * @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,10 +52,10 @@ class TransactionPoolService {
     async #worker(next) {
         try {
             await this.#processTransactions();
-            if (this.#tx_pool.length > 0) {
+            if (this.#txPool.size() > 0) {
                 next(0);
             } else {
-                next(PROCESS_INTERVAL_MS);
+                next(this.#config.processIntervalMs);
             }
         } catch (error) {
             throw new Error(`TransactionPoolService worker error: ${error.message}`);
@@ -60,40 +63,148 @@ class TransactionPoolService {
     }
 
     #createScheduler() {
-        return new Scheduler((next) => this.#worker(next), PROCESS_INTERVAL_MS);
+        return new Scheduler((next) => this.#worker(next), this.#config.processIntervalMs);
     }
 
     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 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.`);
+    }
 }
 
 export default TransactionPoolService;