trac-msb 0.2.13 → 0.2.15

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

@@ -1,154 +1,89 @@
 import b4a from 'b4a'
-import {EventType, ResultCode} from '../../../utils/constants.js';
-import {publicKeyToAddress} from "../../../utils/helpers.js";
-import {Logger} from "../../../utils/logger.js";
-/**
- * @typedef {import('hyperswarm').Connection} Connection
- */
+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);
+    }
+};
 
 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 {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)
     }
 
     /**
-     * Subscribes to periodic validator health checks.
-     * @param {ReadyResource} healthCheckService
+     * 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
      */
-    // 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;
-        }
+    send(message) {
+        const connectedValidators = this.connectedValidators();
 
-        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 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 {
-            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;
-        }
-
-        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}`);
+        if (connectedValidators.length === 0) {
+            throw new Error('ConnectionManager: no connected validators available to send message');
         }
-    };
 
-    #stopHealthCheck(publicKeyHex) {
-        const targetAddress = publicKeyToAddress(publicKeyHex, this.#config);
+        const target = this.pickRandomValidator(connectedValidators);
+        const entry = this.#validators.get(target);
+        if (!entry || !entry.connection || !entry.connection.protocolSession?.has('legacy')) return null;
 
-        if (!this.#healthCheckService) {
-            this.#logger.debug(`stopHealthCheck: no health check service, cannot stop checks for ${targetAddress}`);
-            return;
-        }
         try {
-            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}`);
+            entry.connection.protocolSession.send(message);
+            entry.sent = (entry.sent || 0) + 1;
+        } catch (e) {
+            // Swallow individual send errors.
         }
-    }
 
-    /**
-     * 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;
+        return target;
     }
 
     /**
      * Sends a message through a specific validator without increasing sent messages count.
-     * @param {Object} message - The message to send to the validator.
+     * @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.
+     * @returns {Boolean} True if the message was sent, false otherwise.
      */
-    async sendSingleMessage(message, publicKey) {
+    sendSingleMessage(message, publicKey) {
         let publicKeyHex = this.#toHexString(publicKey);
-        if (!this.connected(publicKeyHex)) {
-            throw new ConnectionManagerError(
-                `Cannot send message: validator ${publicKeyToAddress(publicKey, this.#config)} is not connected.`
-            );
-        }
+        if (!this.exists(publicKeyHex) || !this.connected(publicKeyHex)) return false; // Fail silently
+
         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)}.`
-            );
+        if (!validator || !validator.connection || !validator.connection.protocolSession) return false;
+        try {
+            validator.connection.protocolSession.send(message);
+        } catch (e) {
+            // Swallow individual send errors.
         }
-        return validator.connection.protocolSession.send(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
+     */
+    // TODO: Deprecated/Unused - remove if not needed
+    whiteList(publicKey) {
+        let publicKeyHex = this.#toHexString(publicKey);
+        this.#validators.set(publicKeyHex, { connection: null, sent: 0 });
     }
 
     /**
@@ -160,20 +95,20 @@ class ConnectionManager {
     addValidator(publicKey, connection) {
         let publicKeyHex = this.#toHexString(publicKey);
         if (this.maxConnectionsReached()) {
-            this.#logger.debug('addValidator: max connections reached.');
+            debugLog(`addValidator: max connections reached.`);
             return false;
         }
-        this.#logger.debug(`addValidator: adding validator ${publicKeyToAddress(publicKeyHex, this.#config)}`);
+        debugLog(`addValidator: adding validator ${this.#toAddress(publicKeyHex)}`);
         if (!this.exists(publicKeyHex)) {
-            this.#logger.debug(`addValidator: appending validator ${publicKeyToAddress(publicKeyHex, this.#config)}`);
+            debugLog(`addValidator: appending validator ${this.#toAddress(publicKeyHex)}`);
             this.#append(publicKeyHex, connection);
             return true;
         } else if (!this.connected(publicKeyHex)) {
-            this.#logger.debug(`addValidator: updating validator ${publicKeyToAddress(publicKeyHex, this.#config)}`);
+            debugLog(`addValidator: updating validator ${this.#toAddress(publicKeyHex)}`);
             this.#update(publicKeyHex, connection);
             return true;
         }
-        this.#logger.debug(`addValidator: didn't add validator ${publicKeyToAddress(publicKeyHex, this.#config)}`);
+        debugLog(`addValidator: didn't add validator ${this.#toAddress(publicKeyHex)}`);
         return false; // TODO: Implement better success/failure reporting
     }
 
@@ -182,9 +117,8 @@ class ConnectionManager {
      * @param {String | Buffer} publicKey - The public key hex string of the validator to remove
      */
     remove(publicKey) {
-        this.#logger.debug(`remove: removing validator ${publicKeyToAddress(publicKey, this.#config)}`);
+        debugLog(`remove: removing validator ${this.#toAddress(publicKey)}`);
         const publicKeyHex = this.#toHexString(publicKey);
-        this.#stopHealthCheck(publicKeyHex);
         if (this.exists(publicKeyHex)) {
             // Close the connection socket
             const entry = this.#validators.get(publicKeyHex);
@@ -193,13 +127,12 @@ 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
                 }
             }
-            this.#logger.debug(`remove: removing validator from map: ${publicKeyToAddress(publicKeyHex, this.#config)}. Map size before removal: ${this.#validators.size}.`);
+            debugLog(`remove: removing validator from map: ${this.#toAddress(publicKeyHex)}. Map size before removal: ${this.#validators.size}.`);
             this.#validators.delete(publicKeyHex);
-            this.#logger.debug(`remove: validator removed successfully. Map size is now ${this.#validators.size}.`);
+            debugLog(`remove: validator removed successfully. Map size is now ${this.#validators.size}.`);
         }
     }
 
@@ -273,12 +206,26 @@ class ConnectionManager {
     }
 
     prettyPrint() {
-        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')}`);
+        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);
     }
 
     /**
@@ -310,18 +257,18 @@ class ConnectionManager {
      * @param {Object} connection - The connection object
      */
     #append(publicKey, connection) {
-        this.#logger.debug(`#append: appending validator ${publicKeyToAddress(publicKey, this.#config)}`);
+        debugLog(`#append: appending validator ${this.#toAddress(publicKey)}`);
         const publicKeyHex = this.#toHexString(publicKey);
         if (this.#validators.has(publicKeyHex)) {
             // This should never happen, but just in case, we log it
-            this.#logger.debug(`#append: tried to append existing validator: ${publicKeyToAddress(publicKey, this.#config)}`);
+            debugLog(`#append: tried to append existing validator: ${this.#toAddress(publicKey)}`);
             return;
         }
-        this.#validators.set(publicKeyHex, {connection, sent: 0});
+        this.#validators.set(publicKeyHex, { connection, sent: 0 });
         connection.on('close', () => {
-            this.#logger.debug(`#append: connection closing for validator ${publicKeyToAddress(publicKey, this.#config)}`);
+            debugLog(`#append: connection closing for validator ${this.#toAddress(publicKey)}`);
             this.remove(publicKeyHex);
-            this.#logger.debug(`#append: connection closed for validator ${publicKeyToAddress(publicKey, this.#config)}`);
+            debugLog(`#append: connection closed for validator ${this.#toAddress(publicKey)}`);
         });
     }
 
@@ -336,23 +283,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);
-        this.#logger.debug(`#update: updating validator ${publicKeyToAddress(publicKey, this.#config)}`);
+        debugLog(`#update: updating validator ${this.#toAddress(publicKey)}`);
         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 });
         }
     }
 
-    #toHexString(publicKey) {
-        return b4a.isBuffer(publicKey) ? publicKey.toString('hex') : publicKey;
+    #toAddress(publicKey) {
+        const keyHex = b4a.isBuffer(publicKey) ? publicKey : b4a.from(publicKey, 'hex');
+        return PeerWallet.encodeBech32m(
+            this.#config.addressPrefix,
+            keyHex
+        );
     }
-}
 
-export class ConnectionManagerError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = this.constructor.name;
+    #toHexString(publicKey) {
+        return b4a.isBuffer(publicKey) ? publicKey.toString('hex') : publicKey;
     }
 }
 

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

@@ -1,20 +1,11 @@
-import { generateUUID, publicKeyToAddress, sleep } from '../../../utils/helpers.js';
+import { 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
@@ -25,161 +16,46 @@ class MessageOrchestrator {
         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, 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);
+    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;
             }
-            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 success;
+        return false;
     }
 
-    // TODO: Delete this function after legacy protocol is deprecated
-    async #attemptSendMessageForLegacy(validatorPublicKey, message) {
+    async #attemptSendMessage(validator, message) {
+        let attempts = 0;
         const deductedTxType = operationToPayload(message.type);
-        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);
+        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;
             }
-            return true;
+            attempts++;
         }
+
+        // If all retries fail, remove validator from pool
+        this.connectionManager.remove(validator);
         return false;
     }