trac-msb 0.2.18 → 0.2.20

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

@@ -1,7 +1,7 @@
-import { generateUUID, publicKeyToAddress, sleep } from '../../../utils/helpers.js';
+import { generateUUID, publicKeyToAddress } from '../../../utils/helpers.js';
 import { operationToPayload } from '../../../utils/applyOperations.js';
 import { networkMessageFactory } from "../../../messages/network/v1/networkMessageFactory.js";
-import { NETWORK_CAPABILITIES } from "../../../utils/constants.js";
+import { NETWORK_CAPABILITIES, ResultCode } from "../../../utils/constants.js";
 import {
     unsafeEncodeApplyOperation
 } from "../../../utils/protobuf/operationHelpers.js";
@@ -15,6 +15,10 @@ import { ConnectionManagerError } from './ConnectionManager.js';
 class MessageOrchestrator {
     #config;
     #wallet;
+    #idempotentSuccessCodes = new Set([
+        ResultCode.TX_ALREADY_EXISTS,
+        ResultCode.OPERATION_ALREADY_COMPLETED,
+    ]);
     /**
      * Attempts to send a message to validators with retries and state checks.
      * @param {ConnectionManager} connectionManager - The connection manager instance
@@ -101,7 +105,7 @@ class MessageOrchestrator {
 
             try {
                 success = await this.#attemptSendMessageForLegacy(validatorPublicKey, message);
-            } catch (error) {
+            } catch {
                 success = await this.send(message, retries + 1);
             }
             if (!success) {
@@ -124,7 +128,12 @@ class MessageOrchestrator {
 
             await this.connectionManager.sendSingleMessage(v1Message, validatorPublicKey)
                 .then(
-                    (resultCode) => {
+                    async (resultCode) => {
+                        if (await this.#isIdempotentSuccess(resultCode, message)) {
+                            success = true;
+                            return;
+                        }
+
                         // TODO: When we will deprecate the legacy protocol, we should refactor this scope, to propagate domain-error with result code.
                         const action = resultToValidatorAction(resultCode);
                         switch (action) {
@@ -168,11 +177,50 @@ class MessageOrchestrator {
         return success;
     }
 
+    /**
+     * Determines whether a non-OK result code should be treated as a success due to idempotency.
+     *
+     * This handles the retry scenario where a requester did not receive or accept the response
+     * from the first validator that committed the transaction. On retry, a second validator may
+     * return TX_ALREADY_EXISTS or OPERATION_ALREADY_COMPLETED because the tx was already
+     * processed. Those codes are not errors — they confirm the operation succeeded.
+     *
+     * To safely treat these as success, we check whether the local unsigned state for the tx
+     * has been committed. This ensures we only acknowledge idempotent success when the state
+     * change is actually observable locally, not just because the result code matched.
+     */
+    async #isIdempotentSuccess(resultCode, message) {
+        if (!this.#idempotentSuccessCodes.has(resultCode)) return false;
+
+        const txHash = this.#extractTxHash(message);
+        if (!txHash) return false;
+
+        // A short wait covers the race where a first validator committed the tx
+        // and a retried validator only observes it as "already exists/completed".
+        const timeout = this.#config.messageValidatorResponseTimeout ?? 2000;
+        return await this.waitForUnsignedState(txHash, timeout);
+    }
+
+    async waitForUnsignedState(txHash, timeout) {
+        return this.state.waitForUnsigned(txHash, timeout);
+    }
+
+    #extractTxHash(message) {
+        if (!message || !Number.isInteger(message.type)) return null;
+
+        const payloadKey = operationToPayload(message.type);
+        const txHash = message?.[payloadKey]?.tx;
+        return typeof txHash === 'string' && txHash.length > 0 ? txHash : null;
+    }
+
     // TODO: Delete this function after legacy protocol is deprecated
     async #attemptSendMessageForLegacy(validatorPublicKey, message) {
         const deductedTxType = operationToPayload(message.type);
         await this.connectionManager.sendSingleMessage(message, validatorPublicKey);
-        const appeared = await this.waitForUnsignedState(message[deductedTxType].tx, this.#config.messageValidatorResponseTimeout);
+        const appeared = await this.state.waitForUnsigned(
+            message[deductedTxType].tx,
+            this.#config.messageValidatorResponseTimeout
+        );
         if (appeared) {
             this.incrementSentCount(validatorPublicKey);
             if (this.shouldRemove(validatorPublicKey)) {
@@ -183,18 +231,6 @@ class MessageOrchestrator {
         return false;
     }
 
-    async waitForUnsignedState(txHash, timeout) {
-        // Polls state for the transaction hash for up to timeout ms
-        const start = Date.now();
-        let entry = null;
-        while (Date.now() - start < timeout) {
-            await sleep(200);
-            entry = await this.state.get(txHash)
-            if (entry) return true;
-        }
-        return false;
-    }
-
     incrementSentCount(validatorPubKey) {
         this.connectionManager.incrementSentCount(validatorPubKey);
     }

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

@@ -1,12 +1,18 @@
 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 {isHexString, publicKeyToAddress} from '../../../utils/helpers.js';
+import {V1ProtocolError} from "../protocols/v1/V1ProtocolError.js";
 import b4a from 'b4a';
 
 const PEER_PUBLIC_KEY_HEX_LENGTH = 64;
 
-class PendingRequestService {
+export class PendingRequestServiceTimeoutError extends Error {
+    constructor(requestId, peerAddress, timeoutMs) {
+        super(`Pending request ${requestId} to peer ${peerAddress} timed out after ${timeoutMs} ms.`);
+        this.name = this.constructor.name;
+    }
+}
+
+export default class PendingRequestService {
     #pendingRequests;
     #requestMessageTypes = [NetworkOperationType.LIVENESS_REQUEST, NetworkOperationType.BROADCAST_TRANSACTION_REQUEST];
     #config;
@@ -53,6 +59,7 @@ class PendingRequestService {
     registerPendingRequest(peerPubKeyHex, message) {
         this.#validateRegisterInput(peerPubKeyHex, message);
         const id = message.id;
+        const peerAddress = publicKeyToAddress(peerPubKeyHex, this.#config);
         if (this.#pendingRequests.size >= this.#config.maxPendingRequestsInPendingRequestsService) {
             throw new Error('Maximum number of pending requests reached.');
         }
@@ -66,7 +73,6 @@ class PendingRequestService {
             requestType: message.type,
             requestTxData: this.#extractRequestTxData(message),
             requestedTo: peerPubKeyHex,
-            timeoutMs: this.#config.pendingRequestTimeout,
             timeoutId: null,
             resolve: null,
             reject: null,
@@ -80,12 +86,14 @@ class PendingRequestService {
         entry.timeoutId = setTimeout(() => {
             this.rejectPendingRequest(
                 id,
-                new V1TimeoutError(
-                    `Pending request with ID ${id} from peer ${peerPubKeyHex} timed out after ${entry.timeoutMs} ms.`,
-                    true
-                ));
+                new PendingRequestServiceTimeoutError(
+                    id,
+                    peerAddress,
+                    this.#config.pendingRequestTimeout
+                )
+            );
 
-        }, entry.timeoutMs);
+        }, this.#config.pendingRequestTimeout);
 
         this.#pendingRequests.set(id, entry);
         return promise;
@@ -123,10 +131,7 @@ class PendingRequestService {
     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);
+        entry.reject(error instanceof Error ? error : new Error(error?.message ?? 'Unexpected error'));
         return true;
     }
 
@@ -157,9 +162,9 @@ class PendingRequestService {
             clearTimeout(entry.timeoutId);
             try {
                 entry.reject(
-                    new V1UnexpectedError(
-                        `Pending request ${id} cancelled (shutdown).`,
-                        false)
+                    new V1ProtocolError(
+                        ResultCode.UNEXPECTED_ERROR,
+                        `Pending request ${id} cancelled (shutdown).`)
                 );
             } catch (error) {
                 console.error(`PendingRequestService.close: failed to reject pending request ${id}:`, error);
@@ -168,5 +173,3 @@ class PendingRequestService {
         this.#pendingRequests.clear();
     }
 }
-
-export default PendingRequestService;

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

@@ -3,6 +3,42 @@ import {TRANSACTION_COMMIT_SERVICE_BUFFER_SIZE} from '../../../utils/constants.j
 
 const TX_HASH_HEX_STRING_LENGTH = 64;
 
+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);
+    }
+}
+
 class TransactionCommitService {
     #pendingCommits;
     #config;
@@ -111,39 +147,3 @@ class TransactionCommitService {
 }
 
 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

@@ -4,6 +4,45 @@ 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;
@@ -168,43 +207,4 @@ class TransactionPoolService {
     }
 }
 
-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;

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

@@ -1,5 +1,6 @@
 import b4a from 'b4a';
-import {V1RateLimitedError} from "../protocols/v1/V1ProtocolError.js";
+import {V1ProtocolError} from "../protocols/v1/V1ProtocolError.js";
+import {ResultCode} from "../../../utils/constants.js";
 import {publicKeyToAddress} from "../../../utils/helpers.js";
 
 class TransactionRateLimiterService {
@@ -64,7 +65,7 @@ class TransactionRateLimiterService {
 
     /*
         Handles rate limiting for a peer connection (v1 protocol).
-        If the peer has exceeded the rate limit, it throws RateLimitedError.
+        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) {
@@ -75,7 +76,10 @@ class TransactionRateLimiterService {
         this.#initializePeerConnectionInfoEntry(peer, currentTime);
 
         if (this.#hasExceededRateLimit(peer, currentTime)) {
-            throw new V1RateLimitedError(`Rate limit exceeded for peer ${publicKeyToAddress(connection.remotePublicKey, this.#config)}`);
+            throw new V1ProtocolError(
+                ResultCode.RATE_LIMITED,
+                `Rate limit exceeded for peer ${publicKeyToAddress(connection.remotePublicKey, this.#config)}`
+            );
         }
         this.#updatePeerConnectionInfo(peer, currentTime);
     }
@@ -93,7 +97,7 @@ class TransactionRateLimiterService {
             return;
         }
 
-        for (const [peer, _] of this.#connectionsStatistics.entries()) {
+        for (const [peer] of this.#connectionsStatistics.entries()) {
             if (this.#isConnectionExpired(peer, currentTime)) {
                 this.#connectionsStatistics.delete(peer);
             }