trac-msb 0.2.8 → 0.2.10

package/src/core/network/{messaging → protocols/legacy}/validators/base/BaseResponse.js

@@ -1,7 +1,6 @@
 import b4a from 'b4a';
 import PeerWallet from 'trac-wallet';
-import { bufferToAddress } from '../../../../state/utils/address.js';
-import State from '../../../../state/State.js';
+import State from '../../../../../state/State.js';
 
 /*
     BaseResponse class for handling common validation logic for network responses.
@@ -16,7 +15,7 @@ class BaseResponse {
      * 
      * @param {State} state 
      * @param {PeerWallet} wallet 
-     * @param {object} config
+     * @param {Config} config
      */
     constructor(state, wallet, config) {
         this.#state = state;

package/src/core/network/protocols/shared/handlers/RoleOperationHandler.js

@@ -0,0 +1,88 @@
+import {OperationType} from '../../../../../utils/constants.js';
+import PartialRoleAccess from "../validators/PartialRoleAccess.js";
+import BaseOperationHandler from './base/BaseOperationHandler.js';
+import {applyStateMessageFactory} from "../../../../../messages/state/applyStateMessageFactory.js";
+import {safeEncodeApplyOperation} from "../../../../../utils/protobuf/operationHelpers.js";
+import {normalizeRoleAccessOperation} from "../../../../../utils/normalizers.js";
+
+class RoleOperationHandler extends BaseOperationHandler {
+    #partialRoleAccessValidator;
+    #wallet;
+    #config;
+    #txPoolService;
+
+    /**
+     * @param {State} state
+     * @param {PeerWallet} wallet
+     * @param {TransactionRateLimiterService} rateLimiter
+     * @param {TransactionPoolService} txPoolService
+     * @param {Config} config
+     **/
+    constructor(state, wallet, rateLimiter, txPoolService, config) {
+        super(state, wallet, rateLimiter, txPoolService, config);
+        this.#wallet = wallet;
+        this.#config = config;
+        this.#partialRoleAccessValidator = new PartialRoleAccess(state, this.#wallet.address ,this.#config)
+        this.#txPoolService = txPoolService;
+    }
+
+    get partialRoleAccessValidator() {
+        return this.#partialRoleAccessValidator;
+    }
+
+    async handleOperation(message, connection) {
+        const normalizedPartialRoleAccessPayload = normalizeRoleAccessOperation(message, this.#config)
+        const isValid = await this.partialRoleAccessValidator.validate(normalizedPartialRoleAccessPayload)
+        let completePayload = null
+        if (!isValid) {
+            throw new Error("OperationHandler: partial role access payload validation failed.");
+        }
+        
+        switch (normalizedPartialRoleAccessPayload.type) {
+            case OperationType.ADD_WRITER:
+                completePayload = await applyStateMessageFactory(this.#wallet, this.#config)
+                    .buildCompleteAddWriterMessage(
+                        normalizedPartialRoleAccessPayload.address,
+                        normalizedPartialRoleAccessPayload.rao.tx,
+                        normalizedPartialRoleAccessPayload.rao.txv,
+                        normalizedPartialRoleAccessPayload.rao.iw,
+                        normalizedPartialRoleAccessPayload.rao.in,
+                        normalizedPartialRoleAccessPayload.rao.is,
+                    )
+                break;
+            case OperationType.REMOVE_WRITER:
+                completePayload = await applyStateMessageFactory(this.#wallet, this.#config)
+                    .buildCompleteRemoveWriterMessage(
+                        normalizedPartialRoleAccessPayload.address,
+                        normalizedPartialRoleAccessPayload.rao.tx,
+                        normalizedPartialRoleAccessPayload.rao.txv,
+                        normalizedPartialRoleAccessPayload.rao.iw,
+                        normalizedPartialRoleAccessPayload.rao.in,
+                        normalizedPartialRoleAccessPayload.rao.is,
+                    )
+                break;
+            case OperationType.ADMIN_RECOVERY:
+
+                completePayload = await applyStateMessageFactory(this.#wallet, this.#config)
+                    .buildCompleteAdminRecoveryMessage(
+                        normalizedPartialRoleAccessPayload.address,
+                        normalizedPartialRoleAccessPayload.rao.tx,
+                        normalizedPartialRoleAccessPayload.rao.txv,
+                        normalizedPartialRoleAccessPayload.rao.iw,
+                        normalizedPartialRoleAccessPayload.rao.in,
+                        normalizedPartialRoleAccessPayload.rao.is,
+                    )
+                break;
+            default:
+                throw new Error("OperationHandler: Assembling complete role access operation failed due to unsupported operation type.");
+        }
+
+        if (!completePayload) {
+            throw new Error("OperationHandler: Assembling complete role access operation failed.");
+        }
+
+        this.#txPoolService.addTransaction(safeEncodeApplyOperation(completePayload))
+    }
+}
+
+export default RoleOperationHandler;

package/src/core/network/protocols/shared/handlers/SubnetworkOperationHandler.js

@@ -0,0 +1,93 @@
+import BaseOperationHandler from './base/BaseOperationHandler.js';
+import {
+    OperationType
+} from '../../../../../utils/constants.js';
+import PartialBootstrapDeployment from "../validators/PartialBootstrapDeployment.js";
+import PartialTransaction from "../validators/PartialTransaction.js";
+import {applyStateMessageFactory} from "../../../../../messages/state/applyStateMessageFactory.js";
+import {safeEncodeApplyOperation} from "../../../../../utils/protobuf/operationHelpers.js";
+import {
+    normalizeBootstrapDeploymentOperation,
+    normalizeTransactionOperation
+} from "../../../../../utils/normalizers.js";
+
+
+class SubnetworkOperationHandler extends BaseOperationHandler {
+    #partialBootstrapDeploymentValidator;
+    #partialTransactionValidator;
+    #config;
+    #wallet;
+    #txPoolService;
+
+    /**
+     * @param {State} state
+     * @param {PeerWallet} wallet
+     * @param {TransactionRateLimiterService} rateLimiter
+     * @param {TransactionPoolService} txPoolService
+     * @param {Config} config
+     **/
+    constructor( state, wallet, rateLimiter, txPoolService, config) {
+        super(state, wallet, rateLimiter, txPoolService, config);
+        this.#config = config;
+        this.#wallet = wallet
+        this.#partialBootstrapDeploymentValidator = new PartialBootstrapDeployment(state, this.#wallet.address, config);
+        this.#partialTransactionValidator = new PartialTransaction(state, this.#wallet.address, config);
+        this.#txPoolService = txPoolService;
+    }
+
+    async handleOperation(payload, connection)  {
+        if (payload.type === OperationType.TX) {
+            await this.#partialTransactionSubHandler(payload, connection);
+        } else if (payload.type === OperationType.BOOTSTRAP_DEPLOYMENT) {
+            await this.#partialBootstrapDeploymentSubHandler(payload, connection);
+        } else {
+            throw new Error('Unsupported operation type for SubnetworkOperationHandler');
+        }
+    }
+
+    async #partialTransactionSubHandler(payload, connection) {
+        const normalizedPayload = normalizeTransactionOperation(payload, this.#config);
+        const isValid = await this.#partialTransactionValidator.validate(normalizedPayload);
+        if (!isValid) {
+            throw new Error("SubnetworkHandler: Transaction validation failed.");
+        }
+
+        const completeTransactionOperation = await applyStateMessageFactory(this.#wallet,this.#config)
+            .buildCompleteTransactionOperationMessage(
+                normalizedPayload.address,
+                normalizedPayload.txo.tx,
+                normalizedPayload.txo.txv,
+                normalizedPayload.txo.iw,
+                normalizedPayload.txo.in,
+                normalizedPayload.txo.ch,
+                normalizedPayload.txo.is,
+                normalizedPayload.txo.bs,
+                normalizedPayload.txo.mbs
+            )
+        this.#txPoolService.addTransaction(safeEncodeApplyOperation(completeTransactionOperation));
+    }
+
+    async #partialBootstrapDeploymentSubHandler(payload, connection) {
+        const normalizedPayload = normalizeBootstrapDeploymentOperation(payload, this.#config);
+        const isValid = await this.#partialBootstrapDeploymentValidator.validate(normalizedPayload);
+        if (!isValid) {
+            throw new Error("SubnetworkHandler: Bootstrap deployment validation failed.");
+        }
+
+
+        const completeBootstrapDeploymentOperation = await applyStateMessageFactory(this.#wallet, this.#config)
+            .buildCompleteBootstrapDeploymentMessage(
+                normalizedPayload.address,
+                normalizedPayload.bdo.tx,
+                normalizedPayload.bdo.txv,
+                normalizedPayload.bdo.bs,
+                normalizedPayload.bdo.ic,
+                normalizedPayload.bdo.in,
+                normalizedPayload.bdo.is
+            )
+        this.#txPoolService.addTransaction(safeEncodeApplyOperation(completeBootstrapDeploymentOperation));
+
+    }
+}
+
+export default SubnetworkOperationHandler;

package/src/core/network/{messaging → protocols/shared}/handlers/TransferOperationHandler.js

@@ -1,45 +1,46 @@
 import BaseOperationHandler from './base/BaseOperationHandler.js';
-import CompleteStateMessageOperations
-    from "../../../../messages/completeStateMessages/CompleteStateMessageOperations.js";
-import {OperationType} from '../../../../utils/constants.js';
+import {OperationType} from '../../../../../utils/constants.js';
 import PartialTransfer from "../validators/PartialTransfer.js";
-import {normalizeTransferOperation} from "../../../../utils/normalizers.js"
+import {normalizeTransferOperation} from "../../../../../utils/normalizers.js"
+import {applyStateMessageFactory} from "../../../../../messages/state/applyStateMessageFactory.js";
+import {safeEncodeApplyOperation} from "../../../../../utils/protobuf/operationHelpers.js";
 
 class TransferOperationHandler extends BaseOperationHandler {
     #partialTransferValidator;
     #config;
     #wallet;
+    #txPoolService;
 
     /**
-     * @param {Network} network
      * @param {State} state
      * @param {PeerWallet} wallet
      * @param {TransactionRateLimiterService} rateLimiter
-     * @param {object} config
+     * @param {Config} config
      **/
-    constructor(network, state, wallet, rateLimiter, config) {
-        super(network, state, wallet, rateLimiter, config);
+    constructor(state, wallet, rateLimiter, txPoolService, config) {
+        super(state, wallet, rateLimiter, txPoolService, config);
         this.#config = config;
         this.#wallet = wallet;
-        this.#partialTransferValidator = new PartialTransfer(state, wallet, this.#config);
+        this.#partialTransferValidator = new PartialTransfer(state, this.#wallet.address, this.#config);
+        this.#txPoolService = txPoolService;
     }
 
-    async handleOperation(payload) {
+    async handleOperation(payload, connection) {
         if (payload.type !== OperationType.TRANSFER) {
             throw new Error('Unsupported operation type for TransferOperationHandler');
         }
-        await this.#handleTransfer(payload);
+        await this.#handleTransfer(payload, connection);
     }
 
-    async #handleTransfer(payload) {
+    async #handleTransfer(payload, connection) {
         const normalizedPayload = normalizeTransferOperation(payload, this.#config);
         const isValid = await this.#partialTransferValidator.validate(normalizedPayload);
         if (!isValid) {
             throw new Error("TransferHandler: Transfer validation failed.");
         }
 
-        const completeTransferOperation = await new CompleteStateMessageOperations(this.#wallet, this.#config)
-            .assembleCompleteTransferOperationMessage(
+        const completeTransferOperation = await applyStateMessageFactory(this.#wallet, this.#config)
+            .buildCompleteTransferOperationMessage(
                 normalizedPayload.address,
                 normalizedPayload.tro.tx,
                 normalizedPayload.tro.txv,
@@ -47,9 +48,9 @@ class TransferOperationHandler extends BaseOperationHandler {
                 normalizedPayload.tro.to,
                 normalizedPayload.tro.am,
                 normalizedPayload.tro.is
-            );
+            )
 
-        this.network.transactionPoolService.addTransaction(completeTransferOperation);
+        this.#txPoolService.addTransaction(safeEncodeApplyOperation(completeTransferOperation));
     }
 }
 

package/src/core/network/{messaging → protocols/shared}/handlers/base/BaseOperationHandler.js

@@ -1,40 +1,35 @@
 import b4a from 'b4a';
-import {MAX_PARTIAL_TX_PAYLOAD_BYTE_SIZE, TRANSACTION_POOL_SIZE} from '../../../../../utils/constants.js';
 
 class BaseOperationHandler {
-    #network;
     #state;
     #wallet;
     #rateLimiter;
+    #txPoolService;
     #config;
 
     /**
-     * @param {Network} network
      * @param {State} state
      * @param {PeerWallet} wallet
      * @param {TransactionRateLimiterService} rateLimiter
-     * @param {object} config
+     * @param {TransactionPoolService} txPoolService
+     * @param {Config} config
      **/
-    constructor(network, state, wallet, rateLimiter, config) {
+    constructor(state, wallet, rateLimiter, txPoolService, config) {
         if (new.target === BaseOperationHandler) {
             throw new Error('BaseOperationHandler is abstract and cannot be instantiated directly');
         }
-        this.#network = network;
         this.#state = state;
         this.#wallet = wallet;
         this.#rateLimiter = rateLimiter;
+        this.#txPoolService = txPoolService;
         this.#config = config;
     }
 
-    get network() {
-        return this.#network;
-    }
-
     async validateBasicRequirements(payload, connection) {
         // Validate if operation can be processed:
         // - Non-writable nodes cannot process operations
         // - Regular indexers cannot process operations
-        // - Admin-indexer can process operations only when network has less than MAX_WRITERS_FOR_ADMIN_INDEXER_CONNECTION writers
+        // - Admin-indexer can process operations only when network has less than maxWritersForAdminIndexerConnection writers
         const isAllowedToValidate = await this.#state.allowedToValidate(this.#wallet.address);
         const isAdminAllowedToValidate = await this.#state.isAdminAllowedToValidate();
         const canValidate = isAllowedToValidate || isAdminAllowedToValidate;
@@ -42,16 +37,16 @@ class BaseOperationHandler {
             throw new Error('OperationHandler: State is not writable or is an indexer without admin privileges.');
         }
 
-        if (this.#network.transactionPoolService.tx_pool.length >= TRANSACTION_POOL_SIZE) {
+        if (this.#txPoolService.tx_pool.length >= this.#config.transactionPoolSize) {
             throw new Error("OperationHandler: Transaction pool is full, ignoring incoming transaction.");
         }
 
-        if (b4a.byteLength(JSON.stringify(payload)) > MAX_PARTIAL_TX_PAYLOAD_BYTE_SIZE) {
-            throw new Error(`OperationHandler: Payload size exceeds maximum limit of ${MAX_PARTIAL_TX_PAYLOAD_BYTE_SIZE} bytes by ${b4a.byteLength(JSON.stringify(payload)) - MAX_PARTIAL_TX_PAYLOAD_BYTE_SIZE} bytes.`);
+        if (b4a.byteLength(JSON.stringify(payload)) > this.#config.maxPartialTxPayloadByteSize) {
+            throw new Error(`OperationHandler: Payload size exceeds maximum limit of ${this.#config.maxPartialTxPayloadByteSize} bytes by ${b4a.byteLength(JSON.stringify(payload)) - this.#config.maxPartialTxPayloadByteSize} bytes.`);
         }
         
         if (!this.#config.disableRateLimit) {
-            const shouldDisconnect = this.#rateLimiter.handleRateLimit(connection, this.#network);
+            const shouldDisconnect = this.#rateLimiter.handleRateLimit(connection);
             if (shouldDisconnect) {
                 throw new Error(`OperationHandler: Rate limit exceeded for peer ${b4a.toString(connection.remotePublicKey, 'hex')}. Disconnecting...`);
             }

package/src/core/network/{messaging → protocols/shared}/validators/PartialBootstrapDeployment.js

@@ -1,8 +1,8 @@
 import PartialOperation from './base/PartialOperation.js';
 
 class PartialBootstrapDeployment extends PartialOperation {
-    constructor(state, wallet , config) {
-        super(state, wallet , config);
+    constructor(state, selfAddress , config) {
+        super(state, selfAddress , config);
     }
 
     async validate(payload) {

package/src/core/network/{messaging → protocols/shared}/validators/PartialRoleAccess.js

@@ -1,14 +1,14 @@
 import b4a from 'b4a';
-import {OperationType} from "../../../../utils/constants.js";
-import {bufferToAddress} from "../../../state/utils/address.js";
+import {OperationType} from "../../../../../utils/constants.js";
+import {bufferToAddress} from "../../../../state/utils/address.js";
 import PartialOperation from './base/PartialOperation.js';
-import {bufferToBigInt} from "../../../../utils/amountSerialization.js";
+import {bufferToBigInt} from "../../../../../utils/amountSerialization.js";
 
 class PartialRoleAccess extends PartialOperation {
     #config;
 
-    constructor(state, wallet, config) {
-        super(state, wallet, config);
+    constructor(state, selfAddress, config) {
+        super(state, selfAddress, config);
         this.#config = config
     }
 

package/src/core/network/{messaging → protocols/shared}/validators/PartialTransaction.js

@@ -1,13 +1,13 @@
 import b4a from 'b4a';
-import {safeDecodeApplyOperation} from "../../../../utils/protobuf/operationHelpers.js";
-import deploymentEntryUtils from "../../../state/utils/deploymentEntry.js";
+import {safeDecodeApplyOperation} from "../../../../../utils/protobuf/operationHelpers.js";
+import deploymentEntryUtils from "../../../../state/utils/deploymentEntry.js";
 import PartialOperation from './base/PartialOperation.js';
 
 class PartialTransaction extends PartialOperation {
     #config
 
-    constructor(state, wallet, config) {
-        super(state, wallet, config);
+    constructor(state, selfAddress, config) {
+        super(state, selfAddress, config);
         this.#config = config
     }
 

package/src/core/network/{messaging → protocols/shared}/validators/PartialTransfer.js

@@ -1,14 +1,14 @@
 import PeerWallet from 'trac-wallet';
 
-import {bufferToAddress} from "../../../state/utils/address.js";
-import {bufferToBigInt} from "../../../../utils/amountSerialization.js";
+import {bufferToAddress} from "../../../../state/utils/address.js";
+import {bufferToBigInt} from "../../../../../utils/amountSerialization.js";
 import PartialOperation from './base/PartialOperation.js';
 
 class PartialTransfer extends PartialOperation {
     #config
 
-    constructor(state, wallet, config) {
-        super(state, wallet, config);
+    constructor(state, selfAddress, config) {
+        super(state, selfAddress, config);
         this.#config = config
     }
 

package/src/core/network/{messaging → protocols/shared}/validators/base/PartialOperation.js

@@ -1,12 +1,12 @@
 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} from "../../../../../utils/constants.js";
-import {bufferToBigInt} from "../../../../../utils/amountSerialization.js";
-import {FEE} from "../../../../state/utils/transaction.js";
-import * as operationsUtils from '../../../../../utils/operations.js';
+import Check from '../../../../../../utils/check.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/applyOperations.js';
 
 const MAX_AMOUNT = BigInt('0xffffffffffffffffffffffffffffffff');
 const FEE_BIGINT = bufferToBigInt(FEE);
@@ -16,15 +16,15 @@ class PartialOperation {
     #state;
     #check;
     #config
-    #wallet
+    #selfAddress
 
-    constructor(state, wallet, config) {
+    constructor(state, selfAddress, config) {
         this.#state = state;
         this.#config = config;
         this.#check = new Check(this.#config);
         this.max_amount = MAX_AMOUNT;
         this.fee = FEE_BIGINT;
-        this.#wallet = wallet;
+        this.#selfAddress = selfAddress;
     }
 
     get state() {
@@ -176,7 +176,7 @@ 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
         if (!condition) {
@@ -219,8 +219,10 @@ class PartialOperation {
      * Flow: Validator -> submits tx with tap-wallet -> RPC-> Validator -validates tx-> REJECT (self-validation)
      */
     validateNoSelfValidation(payload) {
+        if (!this.#selfAddress) return;
+
         const requesterAddress = bufferToAddress(payload.address, this.#config.addressPrefix);
-        if (this.#wallet.address === requesterAddress) {
+        if (this.#selfAddress === requesterAddress) {
             throw new Error('Requester address cannot be the same as the validator wallet address.');
         }
     }

package/src/core/network/protocols/v1/NetworkMessageRouter.js

@@ -0,0 +1,15 @@
+import { MessageHeader } from '../../../../utils/protobuf/network.cjs';
+
+class NetworkMessageRouterV1 {
+    #config;
+
+    constructor(config) {
+        this.#config = config;
+    }
+
+    async route(incomingMessage) {
+        MessageHeader.decode(incomingMessage);
+    }
+}
+
+export default NetworkMessageRouterV1;

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

@@ -20,7 +20,7 @@ class ConnectionManager {
     // 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)  {
         this.#validators = new Map();
@@ -44,10 +44,10 @@ class ConnectionManager {
 
         const target = this.pickRandomValidator(connectedValidators);
         const entry = this.#validators.get(target);
-        if (!entry || !entry.connection || !entry.connection.messenger) return null;
+        if (!entry || !entry.connection || !entry.connection.protocolSession?.has('legacy')) return null;
 
         try {
-            entry.connection.messenger.send(message);
+            entry.connection.protocolSession.send(message);
             entry.sent = (entry.sent || 0) + 1;
         } catch (e) {
             // Swallow individual send errors.
@@ -67,9 +67,9 @@ class ConnectionManager {
         if (!this.exists(publicKeyHex) || !this.connected(publicKeyHex)) return false; // Fail silently
 
         const validator = this.#validators.get(publicKeyHex);
-        if (!validator || !validator.connection || !validator.connection.messenger) return false;
+        if (!validator || !validator.connection || !validator.connection.protocolSession) return false;
         try {
-            validator.connection.messenger.send(message);
+            validator.connection.protocolSession.send(message);
         } catch (e) {
             // Swallow individual send errors.
         }

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

@@ -1,5 +1,5 @@
 import { sleep } from '../../../utils/helpers.js';
-import { operationToPayload } from '../../../utils/operations.js';
+import { operationToPayload } from '../../../utils/applyOperations.js';
 /**
  * MessageOrchestrator coordinates message submission, retry, and validator management.
  * It works with ConnectionManager and ledger state to ensure reliable message delivery.
@@ -10,7 +10,7 @@ class MessageOrchestrator {
      * 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;

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

@@ -1,5 +1,5 @@
 // PoolService.js
-import { BATCH_SIZE, PROCESS_INTERVAL_MS } from '../../../utils/constants.js';
+import { BATCH_SIZE } from '../../../utils/constants.js';
 import Scheduler from '../../../utils/Scheduler.js';
 
 class TransactionPoolService {
@@ -12,7 +12,7 @@ class TransactionPoolService {
     /**
      * @param {State} state
      * @param {string} address
-     * @param {object} config
+     * @param {Config} config
      **/
     constructor(state, address, config) {
         this.#state = state;
@@ -37,7 +37,7 @@ class TransactionPoolService {
             console.info('TransactionPoolService can not start. Wallet is not enabled');
             return;
         }
-        if (this.scheduler && this.scheduler.isRunning) {
+        if (this.#scheduler && this.#scheduler.isRunning) {
             console.info('TransactionPoolService is already started');
             return;
         }
@@ -52,7 +52,7 @@ class TransactionPoolService {
             if (this.#tx_pool.length > 0) {
                 next(0);
             } else {
-                next(PROCESS_INTERVAL_MS);
+                next(this.#config.processIntervalMs);
             }
         } catch (error) {
             throw new Error(`TransactionPoolService worker error: ${error.message}`);
@@ -60,12 +60,11 @@ class TransactionPoolService {
     }
 
     #createScheduler() {
-        return new Scheduler((next) => this.#worker(next), PROCESS_INTERVAL_MS);
+        return new Scheduler((next) => this.#worker(next), this.#config.processIntervalMs);
     }
 
     async #processTransactions() {
         const canValidate = await this.#checkValidationPermissions();
-
         if (canValidate && this.#tx_pool.length > 0) {
             const batch = this.#prepareBatch();
             await this.#state.append(batch);