trac-msb 0.2.9 → 0.2.11

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

@@ -1,89 +1,154 @@
 import b4a from 'b4a'
-import PeerWallet from "trac-wallet"
-
-
-// -- 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 [ConnectionManager] ==> ', ...args);
-    }
-};
+import {EventType, ResultCode} from '../../../utils/constants.js';
+import {publicKeyToAddress} from "../../../utils/helpers.js";
+import {Logger} from "../../../utils/logger.js";
+/**
+ * @typedef {import('hyperswarm').Connection} Connection
+ */
 
 class ConnectionManager {
     #validators
     #maxValidators
     #config
-
+    #healthCheckService
+    #boundedHealthCheckHandler
+    #logger
     // Note: #validators is using publicKey (Buffer) as key
     // As Buffers are objects, we will rely on internal conversions done by JS to compare them.
     // It would be better to handle these conversions manually by using hex strings as keys to avoid issues
     /**
-     * @param {object} config
+     * @param {Config} config
      **/
-    constructor(config)  {
+    constructor(config) {
         this.#validators = new Map();
         this.#config = config
         this.#maxValidators = config.maxValidators
+        this.#boundedHealthCheckHandler = this.#healthCheckHandler.bind(this);
+        this.#logger = new Logger(config)
     }
 
     /**
-     * Sends a message to a single randomly selected connected validator.
-     * Returns the public key (buffer) of the validator used, or throws
-     * if the specified validator is unavailable.
-     * @param {Object} message - The message to send to the validator
-     * @returns {String} - The public key of the validator used
+     * Subscribes to periodic validator health checks.
+     * @param {ReadyResource} healthCheckService
      */
-    send(message) {
-        const connectedValidators = this.connectedValidators();
+    // TODO: We should consider moving this to ValidatorObserver instead.
+    // Keep here only if we forsee having health checks for non-validator connections in the future. 
+    // For now, it seems that it would be better to keep this logic here.
+    subscribeToHealthChecks(healthCheckService) {
+        this.#logger.debug('subscribeToHealthChecks: subscribing to health check events');
+        if (!healthCheckService || typeof healthCheckService.on !== 'function' || typeof healthCheckService.off !== 'function') {
+            throw new Error('ConnectionManager: health check service must implement on/off');
+        }
+
+        if (this.#healthCheckService && this.#boundedHealthCheckHandler) {
+            this.#logger.debug('subscribeToHealthChecks: removing previous health check handler');
+            // Unsubscribe from previous health check service if already subscribed
+            // TODO: Maybe we should not allow switching to a new health check service
+            this.#healthCheckService.off(EventType.VALIDATOR_HEALTH_CHECK, this.#boundedHealthCheckHandler);
+        }
+
+        this.#healthCheckService = healthCheckService; // TODO: Maybe this should be handled in the constructor directly?
+        // TODO: declare this method outside this function to avoid redeclaring it every time we subscribe to health checks. We can just bind it to 'this' in the constructor.
+
+        this.#healthCheckService.on(EventType.VALIDATOR_HEALTH_CHECK, this.#boundedHealthCheckHandler);
+        this.#logger.debug('subscribeToHealthChecks: subscribed to health check events');
+    }
+
+    async #healthCheckHandler(publicKey, requestId) {
+        if (typeof publicKey !== 'string' || typeof requestId !== 'string') {
+            // We can't throw here because this is an event handler, but we should at least log the error and return early to avoid further issues.
+            this.#logger.error(`healthCheck: malformed event payload. Typeof publicKey = ${typeof publicKey}. Typeof requestId = ${typeof requestId}`);
+            return;
+        }
 
-        if (connectedValidators.length === 0) {
-            throw new Error('ConnectionManager: no connected validators available to send message');
+        const targetAddress = publicKeyToAddress(publicKey, this.#config);
+
+        if (!this.exists(publicKey) || !this.connected(publicKey)) {
+            this.#logger.debug(`healthCheck: validator not connected, stopping checks. Address = ${targetAddress}; Request ID = ${requestId}`);
+            this.#stopHealthCheck(publicKey);
+            return;
         }
 
-        const target = this.pickRandomValidator(connectedValidators);
-        const entry = this.#validators.get(target);
-        if (!entry || !entry.connection || !entry.connection.protocolSession?.has('legacy')) return null;
+        const connection = this.getConnection(publicKey);
+        if (!connection || !connection.protocolSession || typeof connection.protocolSession.sendHealthCheck !== 'function') {
+            this.#logger.debug(`healthCheck: missing protocol session, removing validator. Address = ${targetAddress}; Request ID = ${requestId}`);
+            this.#stopHealthCheck(publicKey);
+            this.remove(publicKey);
+            return;
+        }
 
+        let success = false;
         try {
-            entry.connection.protocolSession.send(message);
-            entry.sent = (entry.sent || 0) + 1;
-        } catch (e) {
-            // Swallow individual send errors.
+            this.#logger.debug(`healthCheck: sending liveness request. Address = ${targetAddress}; Request ID = ${requestId}`);
+
+            const resultCode = await connection.protocolSession.sendHealthCheck();
+            success = resultCode === ResultCode.OK;
+            if (!success) {
+                this.#logger.debug(`healthCheck: non-OK result code. Address = ${targetAddress}; Request ID = ${requestId}`);
+            }
+        } catch {
+            success = false;
         }
 
-        return target;
-    }
+        if (!success) {
+            this.#logger.debug(`healthCheck: liveness request failed, removing validator. Address = ${targetAddress}; Request ID = ${requestId}`);
+            this.remove(publicKey);
+            this.#stopHealthCheck(publicKey);
+        } else {
+            this.#logger.debug(`healthCheck: success. Address = ${targetAddress}; Request ID = ${requestId}`);
+        }
+    };
 
-    /**
-     * Sends a message through a specific validator without increasing sent messages count.
-     * @param {Object} message - The message to send to the validator
-     * @param {String | Buffer} publicKey - A validator public key hex string to be fetched from the pool.
-     * @returns {Boolean} True if the message was sent, false otherwise.
-     */
-    sendSingleMessage(message, publicKey) {
-        let publicKeyHex = this.#toHexString(publicKey);
-        if (!this.exists(publicKeyHex) || !this.connected(publicKeyHex)) return false; // Fail silently
+    #stopHealthCheck(publicKeyHex) {
+        const targetAddress = publicKeyToAddress(publicKeyHex, this.#config);
 
-        const validator = this.#validators.get(publicKeyHex);
-        if (!validator || !validator.connection || !validator.connection.protocolSession) return false;
+        if (!this.#healthCheckService) {
+            this.#logger.debug(`stopHealthCheck: no health check service, cannot stop checks for ${targetAddress}`);
+            return;
+        }
         try {
-            validator.connection.protocolSession.send(message);
-        } catch (e) {
-            // Swallow individual send errors.
+            if (this.#healthCheckService.has(publicKeyHex)) {
+                this.#logger.debug(`stopHealthCheck: stopping scheduled checks for ${targetAddress}`);
+                this.#healthCheckService.stop(publicKeyHex);
+            }
+        } catch (error) {
+            this.#logger.debug(`stopHealthCheck: failed to stop health check for validator ${targetAddress}. Error: ${error.message}`);
         }
-        return true; // TODO: Implement better success/failure reporting
     }
 
     /**
-     * Creates a blank entry for a validator in the pool without a connection.
-     * @param {String | Buffer} publicKey - The public key hex string of the validator to whitelist
+     * Retrieves the Hyperswarm connection object for a given validator public key.
+     * @param {String | Buffer} publicKey - The public key (Buffer or hex string) of the validator.
+     * @returns {Connection|undefined} - The connection object if found, otherwise undefined.
+     */
+    getConnection(publicKey) {
+        const publicKeyHex = this.#toHexString(publicKey);
+        const entry = this.#validators.get(publicKeyHex);
+        return entry ? entry.connection : undefined;
+    }
+
+    /**
+     * Sends a message through a specific validator without increasing sent messages count.
+     * @param {Object} message - The message to send to the validator.
+     * @param {String | Buffer} publicKey - A validator public key hex string to be fetched from the pool.
+     * @returns {Promise<*>} A promise returned by `validator.connection.protocolSession.send(message)`.
+     * @throws {ConnectionManagerError} If the validator is not connected.
+     * @throws {ConnectionManagerError} If the validator has no valid connection or protocol session.
      */
-    // TODO: Deprecated/Unused - remove if not needed
-    whiteList(publicKey) {
+    async sendSingleMessage(message, publicKey) {
         let publicKeyHex = this.#toHexString(publicKey);
-        this.#validators.set(publicKeyHex, { connection: null, sent: 0 });
+        if (!this.connected(publicKeyHex)) {
+            throw new ConnectionManagerError(
+                `Cannot send message: validator ${publicKeyToAddress(publicKey, this.#config)} is not connected.`
+            );
+        }
+        const validator = this.#validators.get(publicKeyHex);
+        if (!validator || !validator.connection || !validator.connection.protocolSession) {
+            throw new ConnectionManagerError(
+                `Cannot send message: no valid connection found for validator ${publicKeyToAddress(publicKey, this.#config)}.`
+            );
+        }
+        return validator.connection.protocolSession.send(message)
     }
 
     /**
@@ -95,20 +160,20 @@ class ConnectionManager {
     addValidator(publicKey, connection) {
         let publicKeyHex = this.#toHexString(publicKey);
         if (this.maxConnectionsReached()) {
-            debugLog(`addValidator: max connections reached.`);
+            this.#logger.debug('addValidator: max connections reached.');
             return false;
         }
-        debugLog(`addValidator: adding validator ${this.#toAddress(publicKeyHex)}`);
+        this.#logger.debug(`addValidator: adding validator ${publicKeyToAddress(publicKeyHex, this.#config)}`);
         if (!this.exists(publicKeyHex)) {
-            debugLog(`addValidator: appending validator ${this.#toAddress(publicKeyHex)}`);
+            this.#logger.debug(`addValidator: appending validator ${publicKeyToAddress(publicKeyHex, this.#config)}`);
             this.#append(publicKeyHex, connection);
             return true;
         } else if (!this.connected(publicKeyHex)) {
-            debugLog(`addValidator: updating validator ${this.#toAddress(publicKeyHex)}`);
+            this.#logger.debug(`addValidator: updating validator ${publicKeyToAddress(publicKeyHex, this.#config)}`);
             this.#update(publicKeyHex, connection);
             return true;
         }
-        debugLog(`addValidator: didn't add validator ${this.#toAddress(publicKeyHex)}`);
+        this.#logger.debug(`addValidator: didn't add validator ${publicKeyToAddress(publicKeyHex, this.#config)}`);
         return false; // TODO: Implement better success/failure reporting
     }
 
@@ -117,8 +182,9 @@ class ConnectionManager {
      * @param {String | Buffer} publicKey - The public key hex string of the validator to remove
      */
     remove(publicKey) {
-        debugLog(`remove: removing validator ${this.#toAddress(publicKey)}`);
+        this.#logger.debug(`remove: removing validator ${publicKeyToAddress(publicKey, this.#config)}`);
         const publicKeyHex = this.#toHexString(publicKey);
+        this.#stopHealthCheck(publicKeyHex);
         if (this.exists(publicKeyHex)) {
             // Close the connection socket
             const entry = this.#validators.get(publicKeyHex);
@@ -127,12 +193,13 @@ class ConnectionManager {
                     entry.connection.end();
                 } catch (e) {
                     // Ignore errors on connection end
+                    this.#logger.debug(`remove: failed to end connection: ${e.message}`);
                     // TODO: Consider logging these errors here in verbose mode
                 }
             }
-            debugLog(`remove: removing validator from map: ${this.#toAddress(publicKeyHex)}. Map size before removal: ${this.#validators.size}.`);
+            this.#logger.debug(`remove: removing validator from map: ${publicKeyToAddress(publicKeyHex, this.#config)}. Map size before removal: ${this.#validators.size}.`);
             this.#validators.delete(publicKeyHex);
-            debugLog(`remove: validator removed successfully. Map size is now ${this.#validators.size}.`);
+            this.#logger.debug(`remove: validator removed successfully. Map size is now ${this.#validators.size}.`);
         }
     }
 
@@ -206,26 +273,12 @@ class ConnectionManager {
     }
 
     prettyPrint() {
-        console.log('Connection count: ', this.connectionCount())
-        console.log('Validator map keys count: ', this.#validators.size)
-        console.log('Validator map keys: ', Array.from(this.#validators.keys()).map(val => this.#toAddress(val)).join(', '))
-    }
-
-    // Note 1: This method shuffles the whole array (in practice, probably around 50 elements)
-    //      just to fetch a small subset of it (most times, 1 element).
-    //      There are more efficient ways to pick a small subset of validators. Consider optimizing.
-    // Note 2: This method is unused now, but will be kept here for future reference
-    // TODO: Deprecated/Unused - remove if not needed
-    pickRandomSubset(validators, maxTargets) {
-        const copy = validators.slice();
-        const count = Math.min(maxTargets, copy.length);
-
-        for (let i = copy.length - 1; i > 0; i--) {
-            const j = Math.floor(Math.random() * (i + 1));
-            [copy[i], copy[j]] = [copy[j], copy[i]];
-        }
-
-        return copy.slice(0, count);
+        this.#logger.info(`Connection count: ${this.connectionCount()}`);
+        this.#logger.info(`Validator map keys count: ${this.#validators.size}`);
+        this.#logger.info(`Validator map keys:\n${Array.from(this.#validators.entries()).map(([publicKey, val]) => {
+            const protocols = val.connection?.protocolSession?.preferredProtocol || 'none';
+            return `${publicKeyToAddress(publicKey, this.#config)}: ${protocols}`;
+        }).join('\n')}`);
     }
 
     /**
@@ -257,18 +310,18 @@ class ConnectionManager {
      * @param {Object} connection - The connection object
      */
     #append(publicKey, connection) {
-        debugLog(`#append: appending validator ${this.#toAddress(publicKey)}`);
+        this.#logger.debug(`#append: appending validator ${publicKeyToAddress(publicKey, this.#config)}`);
         const publicKeyHex = this.#toHexString(publicKey);
         if (this.#validators.has(publicKeyHex)) {
             // This should never happen, but just in case, we log it
-            debugLog(`#append: tried to append existing validator: ${this.#toAddress(publicKey)}`);
+            this.#logger.debug(`#append: tried to append existing validator: ${publicKeyToAddress(publicKey, this.#config)}`);
             return;
         }
-        this.#validators.set(publicKeyHex, { connection, sent: 0 });
+        this.#validators.set(publicKeyHex, {connection, sent: 0});
         connection.on('close', () => {
-            debugLog(`#append: connection closing for validator ${this.#toAddress(publicKey)}`);
+            this.#logger.debug(`#append: connection closing for validator ${publicKeyToAddress(publicKey, this.#config)}`);
             this.remove(publicKeyHex);
-            debugLog(`#append: connection closed for validator ${this.#toAddress(publicKey)}`);
+            this.#logger.debug(`#append: connection closed for validator ${publicKeyToAddress(publicKey, this.#config)}`);
         });
     }
 
@@ -283,25 +336,24 @@ class ConnectionManager {
         // It would be preferable to keep them separated though, but we would need to review all usages to ensure correctness.
         // Also, we should remove the 'else' branch below if we decide to keep 'update' and 'append' separated.
         const publicKeyHex = this.#toHexString(publicKey);
-        debugLog(`#update: updating validator ${this.#toAddress(publicKey)}`);
+        this.#logger.debug(`#update: updating validator ${publicKeyToAddress(publicKey, this.#config)}`);
         if (this.#validators.has(publicKeyHex)) {
             this.#validators.get(publicKeyHex).connection = connection;
         } else {
-            this.#validators.set(publicKeyHex, { connection, sent: 0 });
+            this.#validators.set(publicKeyHex, {connection, sent: 0});
         }
     }
 
-    #toAddress(publicKey) {
-        const keyHex = b4a.isBuffer(publicKey) ? publicKey : b4a.from(publicKey, 'hex');
-        return PeerWallet.encodeBech32m(
-            this.#config.addressPrefix,
-            keyHex
-        );
-    }
-
     #toHexString(publicKey) {
         return b4a.isBuffer(publicKey) ? publicKey.toString('hex') : publicKey;
     }
 }
 
+export class ConnectionManagerError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = this.constructor.name;
+    }
+}
+
 export default ConnectionManager;

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

@@ -1,61 +1,185 @@
-import { sleep } from '../../../utils/helpers.js';
+import { generateUUID, publicKeyToAddress, sleep } 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 {
+    unsafeEncodeApplyOperation
+} from "../../../utils/protobuf/operationHelpers.js";
+import { normalizeMessageByOperationType } from "../../../utils/normalizers.js";
+import { resultToValidatorAction, SENDER_ACTION } from "../protocols/connectionPolicies.js";
+import { ConnectionManagerError } from './ConnectionManager.js';
 /**
  * MessageOrchestrator coordinates message submission, retry, and validator management.
  * It works with ConnectionManager and ledger state to ensure reliable message delivery.
  */
 class MessageOrchestrator {
     #config;
+    #wallet;
     /**
      * Attempts to send a message to validators with retries and state checks.
      * @param {ConnectionManager} connectionManager - The connection manager instance
      * @param {object} state - The state to look for the message outcome
-     * @param {object} config - Configuration options:
+     * @param {Config} config - Configuration options:
      */
     constructor(connectionManager, state, config) {
         this.connectionManager = connectionManager;
         this.state = state;
         this.#config = config;
+        this.#wallet = null;
+    }
+
+    setWallet(wallet) {
+        this.#wallet = wallet;
+    }
+
+    /**
+     * Picks a validator for an outgoing message while avoiding requester self-validation.
+     *
+     * ValidatorObserverService already prevents connecting to the local node itself.
+     * This method handles a different case: for a given message, we avoid selecting
+     * a validator whose address equals `message.address` (requester), because
+     * validator-side checks reject that flow.
+     *
+     * @param {object} [message] Outgoing operation payload.
+     * @param {string} [message.address] Requester address (bech32m).
+     * @returns {string|null} Selected validator public key hex, or null when unavailable.
+     */
+    #pickValidatorForMessage(message) {
+        const requesterAddress = message?.address;
+        if (!requesterAddress || typeof this.connectionManager.connectedValidators !== 'function') {
+            return this.connectionManager.pickRandomConnectedValidator();
+        }
+
+        const connected = this.connectionManager.connectedValidators();
+        if (!Array.isArray(connected) || connected.length === 0) {
+            return null;
+        }
+
+        const eligible = connected.filter((publicKey) => {
+            return publicKeyToAddress(publicKey, this.#config) !== requesterAddress;
+        });
+
+        const pool = eligible.length > 0 ? eligible : connected;
+        if (typeof this.connectionManager.pickRandomValidator === 'function') {
+            return this.connectionManager.pickRandomValidator(pool);
+        }
+
+        const index = Math.floor(Math.random() * pool.length);
+        return pool[index] ?? null;
     }
 
     /**
      * Sends a message to a single randomly selected connected validator.
      * @param {object} message - The message object to be sent
+     * @param retries - The current retry count for this message
      * @returns {Promise<boolean>} - true if successful, false otherwise
      */
-    async send(message) {
-        const startTime = Date.now();
-        while (Date.now() - startTime < this.#config.messageValidatorResponseTimeout) {
-            const validator = this.connectionManager.pickRandomConnectedValidator();
-            if (!validator) return false;
-
-            const success = await this.#attemptSendMessage(validator, message);
-            if (success) {
-                return true;
+    async send(message, retries = 0) {
+        if (retries > this.#config.maxRetries) {
+            console.warn(`MessageOrchestrator: Max retries reached for message ${JSON.stringify(message)}. Aborting send.`);
+            return false;
+        }
+
+        const validatorPublicKey = this.#pickValidatorForMessage(message);
+        if (!validatorPublicKey) return false;
+        console.log("Sending message to validator:", publicKeyToAddress(validatorPublicKey, this.#config));
+
+        /* NOTE: Since the retry logic for Legacy is handled here, and is very unique to the protocol,
+        * it was decided to not change MessageOrchestrator send method in the refactor to make protocols transparent.
+        * As the Legacy protocol is going to be deprecated soon, it was decided to keep the retry logic 
+        * here instead of abstracting it in the protocol implementation. 
+        * If we were to abstract it, we would need to add protocol-specific logic in the ProtocolSession
+        * or ProtocolInterface, which would make them less clean and more coupled with the specifics of the protocols.
+        * The parts to be refactored in the future are marked with TODO comments.
+        */
+
+        // TODO: After Legacy is deprecated, we don't need to check preferred protocol here.
+        const validatorConnection = this.connectionManager.getConnection(validatorPublicKey);
+        const preferredProtocol = validatorConnection.protocolSession.preferredProtocol;
+        let success = false;
+        if (preferredProtocol === validatorConnection.protocolSession.supportedProtocols.LEGACY) {
+
+            try {
+                success = await this.#attemptSendMessageForLegacy(validatorPublicKey, message);
+            } catch (error) {
+                success = await this.send(message, retries + 1);
             }
+            if (!success) {
+                // Remove validator and retry
+                this.connectionManager.remove(validatorPublicKey);
+                success = await this.send(message, retries + 1);
+            }
+        } else if (preferredProtocol === validatorConnection.protocolSession.supportedProtocols.V1) {
+            // TODO: This is probably better placed inside the V1 protocol definition.
+            // Both protocols should receive a 'canonical' message and solve the encodings internally
+            // Refactor 
+            const normalizedMessage = normalizeMessageByOperationType(message, this.#config)
+            const encodedTransaction = unsafeEncodeApplyOperation(normalizedMessage)
+            const v1Message = await networkMessageFactory(this.#wallet, this.#config)
+                .buildBroadcastTransactionRequest(
+                    generateUUID(),
+                    encodedTransaction,
+                    NETWORK_CAPABILITIES
+                );
+
+            await this.connectionManager.sendSingleMessage(v1Message, validatorPublicKey)
+                .then(
+                    (resultCode) => {
+                        // 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) {
+                            case SENDER_ACTION.SUCCESS:
+                                success = true;
+                                //TODO: Create a function for action below, and replace it also in legacy flow.
+                                this.incrementSentCount(validatorPublicKey);
+                                if (this.shouldRemove(validatorPublicKey)) {
+                                    this.connectionManager.remove(validatorPublicKey);
+                                }
+                                break;
+                            case SENDER_ACTION.ROTATE:
+                                this.connectionManager.remove(validatorPublicKey);
+                                break;
+                            case SENDER_ACTION.NO_ROTATE:
+                                // ignore
+                                break;
+                            default:
+                                this.connectionManager.remove(validatorPublicKey);
+                                console.warn(
+                                    `MessageOrchestrator: Unrecognized action from connectionPolicies: ${action}.
+                                     ResultCode was: ${resultCode}. Removing validator ${publicKeyToAddress(validatorPublicKey, this.#config)}`
+                                );
+                                break;
+                        }
+                    }
+                )
+                .catch(
+                    async (err) => {
+                        if (err instanceof ConnectionManagerError) {
+                            success = await this.send(message, retries + 1);
+                            console.warn(`MessageOrchestrator: Connection Error: ${err.message}`);
+                        } else {
+                            this.connectionManager.remove(validatorPublicKey);
+                            success = await this.send(message, retries + 1);
+                        }
+                    }
+                )
+
         }
-        return false;
+        return success;
     }
 
-    async #attemptSendMessage(validator, message) {
-        let attempts = 0;
+    // TODO: Delete this function after legacy protocol is deprecated
+    async #attemptSendMessageForLegacy(validatorPublicKey, message) {
         const deductedTxType = operationToPayload(message.type);
-        while (attempts <= this.#config.maxRetries) {
-            this.connectionManager.sendSingleMessage(message, validator);
-
-            const appeared = await this.waitForUnsignedState(message[deductedTxType].tx, this.#config.messageValidatorRetryDelay);
-            if (appeared) {
-                this.incrementSentCount(validator);
-                if (this.shouldRemove(validator)) {
-                    this.connectionManager.remove(validator);
-                }
-                return true;
+        await this.connectionManager.sendSingleMessage(message, validatorPublicKey);
+        const appeared = await this.waitForUnsignedState(message[deductedTxType].tx, this.#config.messageValidatorResponseTimeout);
+        if (appeared) {
+            this.incrementSentCount(validatorPublicKey);
+            if (this.shouldRemove(validatorPublicKey)) {
+                this.connectionManager.remove(validatorPublicKey);
             }
-            attempts++;
+            return true;
         }
-
-        // If all retries fail, remove validator from pool
-        this.connectionManager.remove(validator);
         return false;
     }