trac-msb 0.2.7 → 0.2.8

package/src/core/network/messaging/validators/base/PartialOperation.js

@@ -1,13 +1,11 @@
 import b4a from 'b4a';
 import PeerWallet from 'trac-wallet';
-
 import Check from '../../../../../utils/check.js';
-import { bufferToAddress } from "../../../../state/utils/address.js";
-import { createMessage } from "../../../../../utils/buffer.js";
-import { OperationType, NETWORK_ID } from "../../../../../utils/constants.js";
-import { blake3Hash } from "../../../../../utils/crypto.js";
-import { bufferToBigInt } from "../../../../../utils/amountSerialization.js";
-import { FEE } from "../../../../state/utils/transaction.js";
+import {bufferToAddress} from "../../../../state/utils/address.js";
+import {createMessage} from "../../../../../utils/buffer.js";
+import {OperationType} from "../../../../../utils/constants.js";
+import {bufferToBigInt} from "../../../../../utils/amountSerialization.js";
+import {FEE} from "../../../../state/utils/transaction.js";
 import * as operationsUtils from '../../../../../utils/operations.js';
 
 const MAX_AMOUNT = BigInt('0xffffffffffffffffffffffffffffffff');
@@ -17,12 +15,16 @@ const PUBLIC_KEY_LENGTH = 32;
 class PartialOperation {
     #state;
     #check;
+    #config
+    #wallet
 
-    constructor(state) {
+    constructor(state, wallet, config) {
         this.#state = state;
-        this.#check = new Check();
+        this.#config = config;
+        this.#check = new Check(this.#config);
         this.max_amount = MAX_AMOUNT;
         this.fee = FEE_BIGINT;
+        this.#wallet = wallet;
     }
 
     get state() {
@@ -33,7 +35,9 @@ class PartialOperation {
         return this.#check;
     }
 
-    async validate(payload) { throw new Error("Method 'validate()' must be implemented."); }
+    async validate(payload) {
+        throw new Error("Method 'validate()' must be implemented.");
+    }
 
     isPayloadSchemaValid(payload) {
         if (!payload || !payload.type) {
@@ -65,7 +69,7 @@ class PartialOperation {
     }
 
     validateRequesterAddress(payload) {
-        const incomingAddress = bufferToAddress(payload.address);
+        const incomingAddress = bufferToAddress(payload.address, this.#config.addressPrefix);
         if (!incomingAddress) {
             throw new Error('Invalid requesting address in payload.');
         }
@@ -87,7 +91,7 @@ class PartialOperation {
             case OperationType.REMOVE_WRITER:
             case OperationType.ADMIN_RECOVERY:
                 return [
-                    NETWORK_ID,
+                    this.#config.networkId,
                     operation.txv,
                     operation.iw,
                     operation.in,
@@ -95,7 +99,7 @@ class PartialOperation {
                 ];
             case OperationType.BOOTSTRAP_DEPLOYMENT:
                 return [
-                    NETWORK_ID,
+                    this.#config.networkId,
                     operation.txv,
                     operation.bs,
                     operation.ic,
@@ -104,7 +108,7 @@ class PartialOperation {
                 ];
             case OperationType.TX:
                 return [
-                    NETWORK_ID,
+                    this.#config.networkId,
                     operation.txv,
                     operation.iw,
                     operation.ch,
@@ -115,7 +119,7 @@ class PartialOperation {
                 ];
             case OperationType.TRANSFER:
                 return [
-                    NETWORK_ID,
+                    this.#config.networkId,
                     operation.txv,
                     operation.to,
                     operation.am,
@@ -131,12 +135,12 @@ class PartialOperation {
         const operationKey = operationsUtils.operationToPayload(payload.type);
         const operation = payload[operationKey];
 
-        const incomingPublicKey = PeerWallet.decodeBech32mSafe(bufferToAddress(payload.address));
+        const incomingPublicKey = PeerWallet.decodeBech32mSafe(bufferToAddress(payload.address, this.#config.addressPrefix));
         const incomingSignature = operation.is;
         const messageComponents = this.#getMessageComponents(payload);
 
         const message = createMessage(...messageComponents);
-        const messageHash = await blake3Hash(message);
+        const messageHash = await PeerWallet.blake3(message);
         const payloadHash = operation.tx;
         if (!b4a.equals(payloadHash, messageHash)) {
             throw new Error('Regenerated transaction does not match incoming transaction in payload.');
@@ -172,16 +176,16 @@ class PartialOperation {
     isOperationNotCompleted(payload) {
         const operationKey = operationsUtils.operationToPayload(payload.type);
         const operation = payload[operationKey];
-        const { va, vn, vs } = operation;
+        const {va, vn, vs} = operation;
 
-        const condition = !!(va === undefined && vn === undefined && vs === undefined);
+        const condition = va === undefined && vn === undefined && vs === undefined
         if (!condition) {
             throw new Error('Transfer operation must not be completed already (va, vn, vs must be undefined).');
         }
     }
 
     async validateRequesterBalance(payload, signed = false) {
-        const requesterAddress = bufferToAddress(payload.address);
+        const requesterAddress = bufferToAddress(payload.address, this.#config.addressPrefix);
         let requesterEntry;
         if (signed) {
             requesterEntry = await this.state.getNodeEntry(requesterAddress);
@@ -204,11 +208,23 @@ class PartialOperation {
         const operationKey = operationsUtils.operationToPayload(payload.type);
         const operation = payload[operationKey];
         const bs = operation.bs;
-        if (b4a.equals(this.state.bootstrap, bs)) {
+        if (b4a.equals(this.#config.bootstrap, bs)) {
             throw new Error(`External bootstrap is the same as MSB bootstrap: ${bs.toString('hex')}`);
         }
     }
 
+    /*
+     * Guard against self-validation (RPC/orchestrator loop): a validator may receive its own submitted tx for validation.
+     * Even if unlikely, this must be rejected to avoid incorrect failures/punishments.
+     * Flow: Validator -> submits tx with tap-wallet -> RPC-> Validator -validates tx-> REJECT (self-validation)
+     */
+    validateNoSelfValidation(payload) {
+        const requesterAddress = bufferToAddress(payload.address, this.#config.addressPrefix);
+        if (this.#wallet.address === requesterAddress) {
+            throw new Error('Requester address cannot be the same as the validator wallet address.');
+        }
+    }
+
 }
 
 export default PartialOperation;

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

@@ -1,7 +1,6 @@
-import { MAX_VALIDATORS_IN_CONNECTION_POOL } from "../../../utils/constants.js"
 import b4a from 'b4a'
 import PeerWallet from "trac-wallet"
-import { TRAC_NETWORK_MSB_MAINNET_PREFIX } from 'trac-wallet/constants.js';
+
 
 // -- Debug Mode --
 // TODO: Implement a better debug system in the future. This is just temporary.
@@ -15,14 +14,18 @@ const debugLog = (...args) => {
 class ConnectionManager {
     #validators
     #maxValidators
+    #config
 
     // 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
-
-    constructor({ maxValidators }) {
+    /**
+     * @param {object} config
+     **/
+    constructor(config)  {
         this.#validators = new Map();
-        this.#maxValidators = maxValidators || MAX_VALIDATORS_IN_CONNECTION_POOL
+        this.#config = config
+        this.#maxValidators = config.maxValidators
     }
 
     /**
@@ -288,19 +291,10 @@ class ConnectionManager {
         }
     }
 
-    #evictRandomValidator() {
-        const connected = this.connectedValidators();
-        if (connected.length === 0) return;
-
-        const idx = Math.floor(Math.random() * connected.length);
-        const toRemove = connected[idx];
-        this.remove(toRemove);
-    }
-
     #toAddress(publicKey) {
         const keyHex = b4a.isBuffer(publicKey) ? publicKey : b4a.from(publicKey, 'hex');
         return PeerWallet.encodeBech32m(
-            TRAC_NETWORK_MSB_MAINNET_PREFIX, // TODO: This won't work for other networks. Make it dynamic after configuration is available.
+            this.#config.addressPrefix,
             keyHex
         );
     }

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

@@ -1,34 +1,21 @@
 import { sleep } from '../../../utils/helpers.js';
-import {
-    MAX_MESSAGE_SEND_ATTEMPTS,
-    MAX_SUCCESSIVE_MESSAGES_PER_VALIDATOR,
-    MESSAGE_VALIDATOR_RESPONSE_TIMEOUT_MS,
-    MESSAGE_VALIDATOR_RETRY_DELAY_MS
-} from '../../../utils/constants.js';
-
+import { operationToPayload } from '../../../utils/operations.js';
 /**
  * MessageOrchestrator coordinates message submission, retry, and validator management.
  * It works with ConnectionManager and ledger state to ensure reliable message delivery.
  */
 class MessageOrchestrator {
+    #config;
     /**
      * 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} options - { messageThreshold: number, maxRetries: number, retryDelay: number (milliseconds), timeout: number (milliseconds) }
-     * messageThreshold: How many successful sends before removing a validator from the pool
-     * maxRetries: How many times to retry sending a message to a single validator
-     * retryDelay: How long to wait between retries (ms)
-     * timeout: Overall timeout for sending a message (ms)
+     * @param {object} config - Configuration options:
      */
-    constructor(connectionManager, state, options = {}) {
+    constructor(connectionManager, state, config) {
         this.connectionManager = connectionManager;
         this.state = state;
-        // TODO: Adjust these default values or fetch them from config
-        this.messageThreshold = options.messageThreshold || MAX_SUCCESSIVE_MESSAGES_PER_VALIDATOR;
-        this.maxRetries = options.maxRetries || MAX_MESSAGE_SEND_ATTEMPTS; // Amount of retries for a single validator
-        this.retryDelay = options.retryDelay || MESSAGE_VALIDATOR_RETRY_DELAY_MS; // How long to wait before retrying (ms)
-        this.timeout = options.timeout || MESSAGE_VALIDATOR_RESPONSE_TIMEOUT_MS; // Overall timeout for sending a message (ms)
+        this.#config = config;
     }
 
     /**
@@ -38,7 +25,7 @@ class MessageOrchestrator {
      */
     async send(message) {
         const startTime = Date.now();
-        while (Date.now() - startTime < this.timeout) {
+        while (Date.now() - startTime < this.#config.messageValidatorResponseTimeout) {
             const validator = this.connectionManager.pickRandomConnectedValidator();
             if (!validator) return false;
 
@@ -52,10 +39,11 @@ class MessageOrchestrator {
 
     async #attemptSendMessage(validator, message) {
         let attempts = 0;
-        while (attempts < this.maxRetries) {
+        const deductedTxType = operationToPayload(message.type);
+        while (attempts <= this.#config.maxRetries) {
             this.connectionManager.sendSingleMessage(message, validator);
 
-            const appeared = await this.waitForUnsignedState(message.tro.tx, this.retryDelay);
+            const appeared = await this.waitForUnsignedState(message[deductedTxType].tx, this.#config.messageValidatorRetryDelay);
             if (appeared) {
                 this.incrementSentCount(validator);
                 if (this.shouldRemove(validator)) {
@@ -88,7 +76,7 @@ class MessageOrchestrator {
     }
 
     shouldRemove(validatorPubKey) {
-        return this.connectionManager.getSentCount(validatorPubKey) >= this.messageThreshold;
+        return this.connectionManager.getSentCount(validatorPubKey) >= this.#config.messageThreshold;
     }
 }
 

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

@@ -5,14 +5,19 @@ import Scheduler from '../../../utils/Scheduler.js';
 class TransactionPoolService {
     #state;
     #address;
-    #options;
+    #config;
     #tx_pool = [];
     #scheduler = null;
 
-    constructor(state, address, options = {}) {
+    /**
+     * @param {State} state
+     * @param {string} address
+     * @param {object} config
+     **/
+    constructor(state, address, config) {
         this.#state = state;
         this.#address = address;
-        this.#options = options;
+        this.#config = config;
     }
 
     get tx_pool() {
@@ -27,12 +32,8 @@ class TransactionPoolService {
         return this.#address;
     }
 
-    get options() {
-        return this.#options;
-    }
-
     async start() {
-        if (!this.options.enable_wallet) {
+        if (!this.#config.enableWallet) {
             console.info('TransactionPoolService can not start. Wallet is not enabled');
             return;
         }

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

@@ -1,12 +1,14 @@
 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";
+import Network from "../Network.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
+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.
@@ -18,19 +20,31 @@ const debugLog = (...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() {
@@ -65,17 +79,29 @@ class ValidatorObserverService {
 
     async #worker(next) {
         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++) {
+            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);
 
-            next(POLL_INTERVAL)
+            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());
+        }
+        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, validatorListLength) {
@@ -98,30 +124,33 @@ class ValidatorObserverService {
         else {
             debugLog(`Found valid validator to connect after ${attempts} attempts.`);
         }
-        
+
         if (!isValidatorValid) return;
-        
-        const validatorAddress = bufferToAddress(validatorAddressBuffer);
+
+        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) {
-            await this.#network.tryConnect(validatorPubKeyHex, 'validator');
+            this.#network.tryConnect(validatorPubKeyHex, 'validator');
         }
     };
 
     async #isValidatorValid(forbiddenAddress, validatorAddressBuffer, validatorListLength) {
-        if (validatorAddressBuffer === null || b4a.byteLength(validatorAddressBuffer) !== TRAC_ADDRESS_SIZE) return false;
-        
-        const validatorAddress = bufferToAddress(validatorAddressBuffer);
+        if (validatorAddressBuffer === null || b4a.byteLength(validatorAddressBuffer) !== this.#config.addressLength) return false;
+
+        const validatorAddress = bufferToAddress(validatorAddressBuffer, this.#config.addressPrefix);
         if (validatorAddress === forbiddenAddress) return false;
 
         const validatorPubKeyBuffer = PeerWallet.decodeBech32m(validatorAddress);
         const validatorEntry = await this.state.getNodeEntry(validatorAddress);
         const adminEntry = await this.state.getAdminEntry();
 
+        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)
@@ -146,11 +175,7 @@ class ValidatorObserverService {
     }
 
     #shouldRun() {
-        if (!this.#enable_validator_observer || this.#isInterrupted) {
-            return false;
-        }
-
-        return true;
+        return this.#config.enableValidatorObserver && !this.#isInterrupted
     }
 
     async #lengthEntry() {