trac-msb 0.2.6 → 0.2.8

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

@@ -1,27 +1,50 @@
 import PeerWallet from "trac-wallet";
 import b4a from "b4a";
-import { MAX_WRITERS_FOR_ADMIN_INDEXER_CONNECTION, TRAC_ADDRESS_SIZE } from '../../../utils/constants.js';
+import { MAX_WRITERS_FOR_ADMIN_INDEXER_CONNECTION } from '../../../utils/constants.js';
 import { bufferToAddress } from '../../state/utils/address.js';
 import { sleep } from '../../../utils/helpers.js';
 import Scheduler from "../../../utils/Scheduler.js";
-
-const POLL_INTERVAL = 3500 // This was increase since the iterations dont wait for the execution its about 10 * DELAY_INTERVAL
-const DELAY_INTERVAL = 250
+import Network from "../Network.js";
+
+const DELAY_INTERVAL = 50
+const VALIDATOR_CANDIDATES_PER_CYCLE = 10
+const POLL_INTERVAL = (VALIDATOR_CANDIDATES_PER_CYCLE + 1) * DELAY_INTERVAL // This is to avoid more than one instance of the worker running at the same time
+
+// -- 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 [ValidatorObserverService] ==> ', ...args);
+    }
+};
 
 class ValidatorObserverService {
-    #enable_validator_observer;
+    #config;
     #state;
     #network;
     #scheduler;
     #address;
     #isInterrupted
 
-    constructor(network, state, address, options = {}) {
-        this.#enable_validator_observer = options.enable_validator_observer !== false;
+    /**
+     * @param {Network} network
+     * @param {State} state
+     * @param {string} address
+     * @param {object} config
+     **/
+    constructor(network, state, address, config) {
+        this.#config = config
         this.#network = network;
         this.#state = state;
         this.#address = address;
         this.#isInterrupted = false;
+        if (DEBUG) {
+            this.initTimestamp = Date.now();
+            this.reachedMax = false;
+            this.end = 0;
+            this.begin = 0;
+        }
     }
 
     get state() {
@@ -55,36 +78,80 @@ class ValidatorObserverService {
     }
 
     async #worker(next) {
-        if (!this.#network.validatorConnectionManager.maxConnections()) {
+        if (!this.#network.validatorConnectionManager.maxConnectionsReached()) {
+            if (DEBUG) this.begin = Date.now();
             const length = await this.#lengthEntry()
 
             const promises = [];
-            for (let i = 0; i < 10; i++) {
-                promises.push(this.#findValidator(this.#address, length));
+            for (let i = 0; i < VALIDATOR_CANDIDATES_PER_CYCLE; i++) {
+                promises.push(this.#findValidator(this.#address, length + 1));
                 await sleep(DELAY_INTERVAL); // Low key dangerous as the network progresses
             }
             await Promise.all(promises);
+
+            if (DEBUG) this.end = Date.now();
+            debugLog('Worker cycle completed in (ms):', this.end - this.begin, '| Validator Connections:', this.#network.validatorConnectionManager.connectionCount(), " | Pending: ", this.#network.pendingConnectionsCount());
         }
-        next(POLL_INTERVAL)
+        else if (DEBUG) {
+            if (!this.reachedMax) {
+                this.reachedMax = true;
+                debugLog('Max validator connections reached. Skipping this cycle.');
+                const now = Date.now();
+                const elapsed = now - this.initTimestamp;
+                debugLog('>>> Time elapsed since start (ms):', elapsed);
+            }
+        }
+        next(POLL_INTERVAL);
     }
 
-    async #findValidator(address, length) {
-        if (this.#network.validatorConnectionManager.maxConnections() || !this.#shouldRun()) return;
+    async #findValidator(address, validatorListLength) {
+        if (!this.#shouldRun()) return;
+        const maxAttempts = 50; // TODO: make configurable
+        let attempts = 0;
+        let isValidatorValid = false;
+        let validatorAddressBuffer = b4a.alloc(0);
+
+        while (attempts < maxAttempts && !isValidatorValid) {
+            const rndIndex = Math.floor(Math.random() * validatorListLength);
+            validatorAddressBuffer = await this.state.getWriterIndex(rndIndex);
+            isValidatorValid = await this.#isValidatorValid(address, validatorAddressBuffer, validatorListLength);
+            attempts++;
+        }
+
+        if (attempts >= maxAttempts) {
+            debugLog('Max attempts reached without finding a valid validator.');
+        }
+        else {
+            debugLog(`Found valid validator to connect after ${attempts} attempts.`);
+        }
+
+        if (!isValidatorValid) return;
 
-        const rndIndex = Math.floor(Math.random() * length);
-        const validatorAddressBuffer = await this.state.getWriterIndex(rndIndex);
+        const validatorAddress = bufferToAddress(validatorAddressBuffer, this.#config.addressPrefix);
+        const validatorPubKeyBuffer = PeerWallet.decodeBech32m(validatorAddress);
+        const validatorPubKeyHex = validatorPubKeyBuffer.toString('hex');
+        const adminEntry = await this.state.getAdminEntry();
+
+        if (validatorAddress !== adminEntry?.address || validatorListLength < MAX_WRITERS_FOR_ADMIN_INDEXER_CONNECTION) {
+            this.#network.tryConnect(validatorPubKeyHex, 'validator');
+        }
+    };
 
-        if (validatorAddressBuffer === null || b4a.byteLength(validatorAddressBuffer) !== TRAC_ADDRESS_SIZE) return;
+    async #isValidatorValid(forbiddenAddress, validatorAddressBuffer, validatorListLength) {
+        if (validatorAddressBuffer === null || b4a.byteLength(validatorAddressBuffer) !== this.#config.addressLength) return false;
 
-        const validatorAddress = bufferToAddress(validatorAddressBuffer);
-        if (validatorAddress === address) return;
+        const validatorAddress = bufferToAddress(validatorAddressBuffer, this.#config.addressPrefix);
+        if (validatorAddress === forbiddenAddress) return false;
 
-        const validatorPubKey = PeerWallet.decodeBech32m(validatorAddress).toString('hex');
+        const validatorPubKeyBuffer = PeerWallet.decodeBech32m(validatorAddress);
         const validatorEntry = await this.state.getNodeEntry(validatorAddress);
         const adminEntry = await this.state.getAdminEntry();
 
-        if (validatorAddress === adminEntry?.address && length >= MAX_WRITERS_FOR_ADMIN_INDEXER_CONNECTION) {
-            const validatorPubKeyBuffer = b4a.from(validatorPubKey, 'hex')
+        if (this.#network.isConnectionPending(validatorPubKeyBuffer.toString('hex'))) {
+            return false;
+        }
+
+        if (validatorAddress === adminEntry?.address && validatorListLength >= MAX_WRITERS_FOR_ADMIN_INDEXER_CONNECTION) {
             if (this.#network.validatorConnectionManager.exists(validatorPubKeyBuffer)) {
                 this.#network.validatorConnectionManager.remove(validatorPubKeyBuffer)
             }
@@ -95,28 +162,22 @@ class ValidatorObserverService {
         // - Validator must exist and be a writer
         // - Cannot connect to indexers, except for admin-indexer
         // - Admin-indexer connection is allowed only when writers length has less than 10 writers
-        if (
-            this.#network.validatorConnectionManager.connected(validatorPubKey) ||
+        if (this.#network.validatorConnectionManager.connected(validatorPubKeyBuffer) ||
+            this.#network.validatorConnectionManager.maxConnectionsReached() ||
             validatorEntry === null ||
             !validatorEntry.isWriter ||
-            (validatorEntry.isIndexer && (validatorAddress !== adminEntry?.address || length >= MAX_WRITERS_FOR_ADMIN_INDEXER_CONNECTION))
+            (validatorEntry.isIndexer && (validatorAddress !== adminEntry?.address || validatorListLength >= MAX_WRITERS_FOR_ADMIN_INDEXER_CONNECTION))
         ) {
-            return;
-        }
-
-        if (validatorAddress !== adminEntry?.address || length < MAX_WRITERS_FOR_ADMIN_INDEXER_CONNECTION) {
-            await this.#network.tryConnect(validatorPubKey, 'validator');
-        }
-    };
-
-    #shouldRun() {
-        if (!this.#enable_validator_observer || this.#isInterrupted) {
             return false;
         }
 
         return true;
     }
 
+    #shouldRun() {
+        return this.#config.enableValidatorObserver && !this.#isInterrupted
+    }
+
     async #lengthEntry() {
         const lengthEntry = await this.state.getWriterLength();
         return Number.isInteger(lengthEntry) && lengthEntry > 0 ? lengthEntry : 0;