trac-msb 0.2.11 → 0.2.12

package/src/core/network/protocols/V1Protocol.js

@@ -1,20 +1,18 @@
 import Protomux from 'protomux';
 import ProtocolInterface from './ProtocolInterface.js';
+import b4a from 'b4a';
 import c from 'compact-encoding';
-import {encodeV1networkOperation, decodeV1networkOperation} from '../../../utils/protobuf/operationHelpers.js';
 
 class V1Protocol extends ProtocolInterface {
     #channel;
     #session;
+    #config;
     #router;
-    #publicKeyHex;
-    #pendingRequestService;
 
-    constructor(router, connection, pendingRequestService, config) {
-        super(router, connection, pendingRequestService, config);
+    constructor(router, connection, config) {
+        super(router, connection, config);
+        this.#config = config;
         this.#router = router;
-        this.#publicKeyHex = connection.remotePublicKey.toString('hex');
-        this.#pendingRequestService = pendingRequestService;
         this.init(connection);
     }
 
@@ -32,47 +30,30 @@ class V1Protocol extends ProtocolInterface {
 
         this.#channel = mux.createChannel({
             protocol: 'network/v1',
-            onopen() {
-            },
-            onclose() {
-            }
+            onopen() { },
+            onclose() { }
         });
 
         this.#channel.open();
 
         this.#session = this.#channel.addMessage({
             encoding: c.raw,
-            onmessage: (incomingMessage) => {
-                this.#router.route(incomingMessage, connection).catch((err) => {
-                    console.error(`V1Protocol: unhandled router error: ${err.message}`);
-                    try {
-                        connection.end();
-                    } catch {
+            onmessage: async (incomingMessage) => {
+                try {
+                    if (b4a.isBuffer(incomingMessage)) {
+                        await this.#router.route(incomingMessage, connection, this.#session);
+                    } else {
+                        throw new Error('NetworkMessages: v1 message must be a buffer');
                     }
-                });
+                } catch (error) {
+                    console.error(`NetworkMessages: Failed to handle incoming v1 message: ${error.message}`);
+                }
             }
         });
     }
 
-    // TODO: Consider making this method private/internal-only, just like 'encode'
-    // NOTE: This method might be moved to v1/NetworkMessageRouter.js as it is only used there
-    decode(message) {
-        return decodeV1networkOperation(message);
-    }
-
-    async send(message) {
-        const encodedMessage = encodeV1networkOperation(message);
-        const msgReplyPromise = this.#pendingRequestService.registerPendingRequest(this.#publicKeyHex, message);
-        try {
-            this.#session.send(encodedMessage);
-        } catch (error) {
-            this.#pendingRequestService.rejectPendingRequest(message.id, error);
-        }
-        return msgReplyPromise;
-    }
-
-    sendAndForget(message) {
-        this.#session.send(encodeV1networkOperation(message));
+    send(message) {
+        this.#session.send(message);
     }
 
     close() {

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

@@ -1,12 +1,13 @@
 import b4a from "b4a";
-import _ from 'lodash';
-import LegacyGetRequestHandler from "./handlers/LegacyGetRequestHandler.js";
-import LegacyResponseHandler from "./handlers/LegacyResponseHandler.js";
-import LegacyRoleOperationHandler from "./handlers/LegacyRoleOperationHandler.js";
-import LegacySubnetworkOperationHandler from "./handlers/LegacySubnetworkOperationHandler.js";
-import LegacyTransferOperationHandler from "./handlers/LegacyTransferOperationHandler.js";
+import GetRequestHandler from "./handlers/GetRequestHandler.js";
+import ResponseHandler from "./handlers/ResponseHandler.js";
+import RoleOperationHandler from "../shared/handlers/RoleOperationHandler.js";
+import SubnetworkOperationHandler from "../shared/handlers/SubnetworkOperationHandler.js";
+import TransferOperationHandler from "../shared/handlers/TransferOperationHandler.js";
 import { NETWORK_MESSAGE_TYPES } from '../../../../utils/constants.js';
 import * as operation from '../../../../utils/applyOperations.js';
+import State from "../../../state/State.js";
+import PeerWallet from "trac-wallet";
 
 class NetworkMessageRouter {
     #handlers;
@@ -17,32 +18,29 @@ class NetworkMessageRouter {
      * @param {PeerWallet} wallet
      * @param {TransactionRateLimiterService} rateLimiterService
      * @param {TransactionPoolService} txPoolService
+     * @param {ConnectionManager} connectionManager
      * @param {Config} config
      **/
-    constructor(state, wallet, rateLimiterService, txPoolService, config) {
+    constructor(state, wallet, rateLimiterService, txPoolService, connectionManager, config) {
         this.#config = config;
 
         this.#handlers = {
-            get: new LegacyGetRequestHandler(wallet, state),
-            response: new LegacyResponseHandler(state, wallet, this.#config),
-            roleTransaction: new LegacyRoleOperationHandler(state, wallet, rateLimiterService, txPoolService, this.#config),
-            subNetworkTransaction: new LegacySubnetworkOperationHandler(state, wallet, rateLimiterService, txPoolService, this.#config),
-            tracNetworkTransaction: new LegacyTransferOperationHandler(state, wallet, rateLimiterService, txPoolService, this.#config),
-
+            get: new GetRequestHandler(wallet, state),
+            response: new ResponseHandler(state, wallet, connectionManager, this.#config),
+            roleTransaction: new RoleOperationHandler(state, wallet, rateLimiterService, txPoolService, this.#config),
+            subNetworkTransaction: new SubnetworkOperationHandler(state, wallet, rateLimiterService, txPoolService, this.#config),
+            tracNetworkTransaction: new TransferOperationHandler(state, wallet, rateLimiterService, txPoolService, this.#config),
         }
     }
 
-    async route(incomingMessage, connection) {
-        this.#preValidate(incomingMessage);
+    // NOTE: messageProtomux can be deleted, ad this is a session, and we can extract this from connection
+    async route(incomingMessage, connection, messageProtomux) {
         const channelString = b4a.toString(this.#config.channel, 'utf8');
-
-        // We received a legacy message, so we set the connection protocol accordingly
-        connection.protocolSession.setLegacyAsPreferredProtocol();
         if (this.#isGetRequest(incomingMessage)) {
-            await this.#handlers.get.handle(incomingMessage, connection, channelString);
+            await this.#handlers.get.handle(incomingMessage, messageProtomux, connection, channelString);
         }
         else if (this.#isResponse(incomingMessage)) {
-            await this.#handlers.response.handle(incomingMessage, channelString);
+            await this.#handlers.response.handle(incomingMessage, connection, channelString);
         }
         else if (this.#isRoleAccessOperation(incomingMessage)) {
             await this.#handlers.roleTransaction.handle(incomingMessage, connection);
@@ -56,18 +54,14 @@ class NetworkMessageRouter {
         else {
             throw new Error(`Failed to route message. Pubkey of requester is ${connection.remotePublicKey ? b4a.toString(connection.remotePublicKey, 'hex') : 'unknown'}`);
         }
-    }
 
-    #preValidate(message) {
-        if (!_.isPlainObject(message) && typeof message !== 'string') {
-            throw new Error('Invalid message format: expected object or string.');
-        }
     }
 
     #isGetRequest(message) {
         return Object.values(NETWORK_MESSAGE_TYPES.GET).includes(message);
     }
 
+
     #isResponse(message) {
         return Object.values(NETWORK_MESSAGE_TYPES.RESPONSE).includes(message.op);
     }

package/src/core/network/protocols/legacy/handlers/{LegacyGetRequestHandler.js → GetRequestHandler.js}

@@ -2,7 +2,7 @@ import { NETWORK_MESSAGE_TYPES } from '../../../../../utils/constants.js';
 import PeerWallet from 'trac-wallet';
 import b4a from 'b4a';
 
-class LegacyGetRequestHandler {
+class GetRequestHandler {
     #wallet;
     #state;
 
@@ -15,17 +15,17 @@ class LegacyGetRequestHandler {
         return this.#state;
     }
 
-    async handle(message, connection, channelString) {
+    async handle(message, messageProtomux, connection, channelString) {
         switch (message) {
             case NETWORK_MESSAGE_TYPES.GET.VALIDATOR:
-                await this.handleGetValidatorResponse(connection, channelString);
+                await this.handleGetValidatorResponse(messageProtomux, connection, channelString);
                 break;
             default:
                 throw new Error(`Unhandled GET type: ${message}`);
         }
     }
 
-    async handleGetValidatorResponse(connection, channelString) {
+    async handleGetValidatorResponse(messageProtomux, connection, channelString) {
         const nonce = PeerWallet.generateNonce().toString('hex');
         const payload = {
             op: 'validatorResponse',
@@ -46,8 +46,8 @@ class LegacyGetRequestHandler {
             ...payload,
             sig: sig.toString('hex'),
         };
-        connection.protocolSession.sendAndForget(responseMessage)
+        messageProtomux.send(responseMessage);
     }
 }
 
-export default LegacyGetRequestHandler;
+export default GetRequestHandler;

package/src/core/network/protocols/legacy/handlers/ResponseHandler.js

@@ -0,0 +1,37 @@
+import ValidatorResponse from '../validators/ValidatorResponse.js';
+import PeerWallet from 'trac-wallet';
+
+class ResponseHandler {
+    #responseValidator;
+    #connectionManager;
+
+    
+    constructor(state, wallet, connectionManager ,config) {
+        this.#responseValidator = new ValidatorResponse(state, wallet, config);
+        this.#connectionManager = connectionManager;
+
+    }
+
+    async handle(message, connection, channelString) {
+        await this.#handleValidatorResponse(message, connection, channelString);
+    }
+
+    async #handleValidatorResponse(message, connection, channelString) {
+        const isValid = await this.#responseValidator.validate(message, channelString);
+        if (isValid) {
+            const validatorAddressString = message.address;
+            const validatorPublicKey = PeerWallet.decodeBech32m(validatorAddressString);
+
+            if (this.#connectionManager.connected(validatorPublicKey)) {
+                return;
+                // TODO: What we should return? Or maybe we should throw?
+            }
+
+            this.#connectionManager.addValidator(validatorPublicKey, connection)
+        } else {
+            throw new Error("Validator response verification failed");
+        }
+    }
+}
+
+export default ResponseHandler;

package/src/core/network/protocols/{legacy/handlers/LegacyRoleOperationHandler.js → shared/handlers/RoleOperationHandler.js}

@@ -1,16 +1,15 @@
 import {OperationType} from '../../../../../utils/constants.js';
-import PartialRoleAccessValidator from "../../shared/validators/PartialRoleAccessValidator.js";
-import BaseStateOperationHandler from './BaseStateOperationHandler.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";
-import { publicKeyToAddress } from "../../../../../utils/helpers.js"
-import b4a from "b4a";
 
-class LegacyRoleOperationHandler extends BaseStateOperationHandler {
+class RoleOperationHandler extends BaseOperationHandler {
     #partialRoleAccessValidator;
     #wallet;
     #config;
+    #txPoolService;
 
     /**
      * @param {State} state
@@ -23,7 +22,8 @@ class LegacyRoleOperationHandler extends BaseStateOperationHandler {
         super(state, wallet, rateLimiter, txPoolService, config);
         this.#wallet = wallet;
         this.#config = config;
-        this.#partialRoleAccessValidator = new PartialRoleAccessValidator(state, this.#wallet.address ,this.#config)
+        this.#partialRoleAccessValidator = new PartialRoleAccess(state, this.#wallet.address ,this.#config)
+        this.#txPoolService = txPoolService;
     }
 
     get partialRoleAccessValidator() {
@@ -35,8 +35,7 @@ class LegacyRoleOperationHandler extends BaseStateOperationHandler {
         const isValid = await this.partialRoleAccessValidator.validate(normalizedPartialRoleAccessPayload)
         let completePayload = null
         if (!isValid) {
-            throw new Error(
-                `OperationHandler: partial role access payload validation failed. Requested by ${publicKeyToAddress(connection.remotePublicKey, this.#config)}`);
+            throw new Error("OperationHandler: partial role access payload validation failed.");
         }
         
         switch (normalizedPartialRoleAccessPayload.type) {
@@ -75,21 +74,15 @@ class LegacyRoleOperationHandler extends BaseStateOperationHandler {
                     )
                 break;
             default:
-                throw new Error(
-                    `OperationHandler: Assembling complete role access operation failed due to unsupported operation type. Requested by ${publicKeyToAddress(connection.remotePublicKey, this.#config)}`
-                );
+                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. Requested by ${publicKeyToAddress(connection.remotePublicKey, this.#config)}`
-            );
+            throw new Error("OperationHandler: Assembling complete role access operation failed.");
         }
 
-        const encodedOperation = safeEncodeApplyOperation(completePayload);
-        const txHash =  b4a.toString(completePayload.rao.tx, 'hex');
-        this.enqueueTransaction(txHash, encodedOperation);
+        this.#txPoolService.addTransaction(safeEncodeApplyOperation(completePayload))
     }
 }
 
-export default LegacyRoleOperationHandler;
+export default RoleOperationHandler;

package/src/core/network/protocols/{legacy/handlers/LegacySubnetworkOperationHandler.js → shared/handlers/SubnetworkOperationHandler.js}

@@ -1,24 +1,23 @@
-import BaseStateOperationHandler from './BaseStateOperationHandler.js';
+import BaseOperationHandler from './base/BaseOperationHandler.js';
 import {
     OperationType
 } from '../../../../../utils/constants.js';
-import PartialBootstrapDeploymentValidator from "../../shared/validators/PartialBootstrapDeploymentValidator.js";
-import PartialTransactionValidator from "../../shared/validators/PartialTransactionValidator.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";
-import b4a from "b4a";
-import {publicKeyToAddress} from "../../../../../utils/helpers.js";
 
 
-class LegacySubnetworkOperationHandler extends BaseStateOperationHandler {
+class SubnetworkOperationHandler extends BaseOperationHandler {
     #partialBootstrapDeploymentValidator;
     #partialTransactionValidator;
     #config;
     #wallet;
+    #txPoolService;
 
     /**
      * @param {State} state
@@ -27,23 +26,22 @@ class LegacySubnetworkOperationHandler extends BaseStateOperationHandler {
      * @param {TransactionPoolService} txPoolService
      * @param {Config} config
      **/
-    constructor(state, wallet, rateLimiter, txPoolService, config) {
+    constructor( state, wallet, rateLimiter, txPoolService, config) {
         super(state, wallet, rateLimiter, txPoolService, config);
         this.#config = config;
         this.#wallet = wallet
-        this.#partialBootstrapDeploymentValidator = new PartialBootstrapDeploymentValidator(state, this.#wallet.address, config);
-        this.#partialTransactionValidator = new PartialTransactionValidator(state, this.#wallet.address, config);
+        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) {
+    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 LegacySubnetworkOperationHandler. Requested by ${publicKeyToAddress(connection.remotePublicKey, this.#config)} `
-            );
+            throw new Error('Unsupported operation type for SubnetworkOperationHandler');
         }
     }
 
@@ -51,12 +49,10 @@ class LegacySubnetworkOperationHandler extends BaseStateOperationHandler {
         const normalizedPayload = normalizeTransactionOperation(payload, this.#config);
         const isValid = await this.#partialTransactionValidator.validate(normalizedPayload);
         if (!isValid) {
-            throw new Error(`
-                SubnetworkHandler: Transaction validation failed. Requested by ${publicKeyToAddress(connection.remotePublicKey, this.#config)}`
-            );
+            throw new Error("SubnetworkHandler: Transaction validation failed.");
         }
 
-        const completeTransactionOperation = await applyStateMessageFactory(this.#wallet, this.#config)
+        const completeTransactionOperation = await applyStateMessageFactory(this.#wallet,this.#config)
             .buildCompleteTransactionOperationMessage(
                 normalizedPayload.address,
                 normalizedPayload.txo.tx,
@@ -68,19 +64,14 @@ class LegacySubnetworkOperationHandler extends BaseStateOperationHandler {
                 normalizedPayload.txo.bs,
                 normalizedPayload.txo.mbs
             )
-        const encodedOperation = safeEncodeApplyOperation(completeTransactionOperation);
-        const txHash = b4a.toString(normalizedPayload.txo.tx, 'hex');
-        this.enqueueTransaction(txHash, encodedOperation);
-
+        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. Requested by ${publicKeyToAddress(connection.remotePublicKey, this.#config)}`
-            );
+            throw new Error("SubnetworkHandler: Bootstrap deployment validation failed.");
         }
 
 
@@ -94,11 +85,9 @@ class LegacySubnetworkOperationHandler extends BaseStateOperationHandler {
                 normalizedPayload.bdo.in,
                 normalizedPayload.bdo.is
             )
-        const encodedOperation = safeEncodeApplyOperation(completeBootstrapDeploymentOperation);
-        const txHash = b4a.toString(normalizedPayload.bdo.tx, 'hex');
-        this.enqueueTransaction(txHash, encodedOperation);
+        this.#txPoolService.addTransaction(safeEncodeApplyOperation(completeBootstrapDeploymentOperation));
 
     }
 }
 
-export default LegacySubnetworkOperationHandler;
+export default SubnetworkOperationHandler;

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

@@ -1,36 +1,33 @@
-import BaseStateOperationHandler from './BaseStateOperationHandler.js';
+import BaseOperationHandler from './base/BaseOperationHandler.js';
 import {OperationType} from '../../../../../utils/constants.js';
-import PartialTransferValidator from "../../shared/validators/PartialTransferValidator.js";
+import PartialTransfer from "../validators/PartialTransfer.js";
 import {normalizeTransferOperation} from "../../../../../utils/normalizers.js"
 import {applyStateMessageFactory} from "../../../../../messages/state/applyStateMessageFactory.js";
 import {safeEncodeApplyOperation} from "../../../../../utils/protobuf/operationHelpers.js";
-import b4a from "b4a";
-import {publicKeyToAddress} from "../../../../../utils/helpers.js";
 
-class LegacyTransferOperationHandler extends BaseStateOperationHandler {
+class TransferOperationHandler extends BaseOperationHandler {
     #partialTransferValidator;
     #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.#partialTransferValidator = new PartialTransferValidator(state, this.#wallet.address, this.#config);
+        this.#partialTransferValidator = new PartialTransfer(state, this.#wallet.address, this.#config);
+        this.#txPoolService = txPoolService;
     }
 
     async handleOperation(payload, connection) {
         if (payload.type !== OperationType.TRANSFER) {
-            throw new Error(
-                `Unsupported operation type for LegacyTransferOperationHandler. Requested by ${publicKeyToAddress(connection.remotePublicKey, this.#config)}`
-            );
+            throw new Error('Unsupported operation type for TransferOperationHandler');
         }
         await this.#handleTransfer(payload, connection);
     }
@@ -39,9 +36,7 @@ class LegacyTransferOperationHandler extends BaseStateOperationHandler {
         const normalizedPayload = normalizeTransferOperation(payload, this.#config);
         const isValid = await this.#partialTransferValidator.validate(normalizedPayload);
         if (!isValid) {
-            throw new Error(
-                `TransferHandler: Transfer validation failed. Requested by ${publicKeyToAddress(connection.remotePublicKey, this.#config)}`
-            );
+            throw new Error("TransferHandler: Transfer validation failed.");
         }
 
         const completeTransferOperation = await applyStateMessageFactory(this.#wallet, this.#config)
@@ -54,10 +49,9 @@ class LegacyTransferOperationHandler extends BaseStateOperationHandler {
                 normalizedPayload.tro.am,
                 normalizedPayload.tro.is
             )
-        const encodedOperation = safeEncodeApplyOperation(completeTransferOperation);
-        const txHash =  b4a.toString(normalizedPayload.tro.tx, 'hex');
-        this.enqueueTransaction(txHash, encodedOperation);
+
+        this.#txPoolService.addTransaction(safeEncodeApplyOperation(completeTransferOperation));
     }
 }
 
-export default LegacyTransferOperationHandler;
+export default TransferOperationHandler;

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

@@ -1,7 +1,6 @@
 import b4a from 'b4a';
-import {publicKeyToAddress} from "../../../../../utils/helpers.js";
 
-class BaseStateOperationHandler {
+class BaseOperationHandler {
     #state;
     #wallet;
     #rateLimiter;
@@ -16,8 +15,8 @@ class BaseStateOperationHandler {
      * @param {Config} config
      **/
     constructor(state, wallet, rateLimiter, txPoolService, config) {
-        if (new.target === BaseStateOperationHandler) {
-            throw new Error('BaseStateOperationHandler is abstract and cannot be instantiated directly');
+        if (new.target === BaseOperationHandler) {
+            throw new Error('BaseOperationHandler is abstract and cannot be instantiated directly');
         }
         this.#state = state;
         this.#wallet = wallet;
@@ -38,18 +37,18 @@ class BaseStateOperationHandler {
             throw new Error('OperationHandler: State is not writable or is an indexer without admin privileges.');
         }
 
-        this.#txPoolService.validateEnqueue();
-        if (b4a.byteLength(JSON.stringify(payload)) > this.#config.transactionPoolSize) {
-            throw new Error(
-                `OperationHandler: Payload size exceeds maximum limit of ${this.#config.transactionPoolSize} bytes by ${b4a.byteLength(JSON.stringify(payload)) - this.#config.transactionPoolSize} bytes.`);
+        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)) > 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.legacyHandleRateLimit(connection);
+            const shouldDisconnect = this.#rateLimiter.handleRateLimit(connection);
             if (shouldDisconnect) {
-                throw new Error(
-                    `OperationHandler: Rate limit exceeded for ${publicKeyToAddress(connection.remotePublicKey, this.#config)}. Disconnecting...`
-                );
+                throw new Error(`OperationHandler: Rate limit exceeded for peer ${b4a.toString(connection.remotePublicKey, 'hex')}. Disconnecting...`);
             }
         }
     }
@@ -59,19 +58,9 @@ class BaseStateOperationHandler {
         await this.handleOperation(payload, connection);
     }
 
-    enqueueTransaction(txHash, encodedOperation) {
-        try {
-            this.#txPoolService.addTransaction(txHash, encodedOperation);
-        } catch (error) {
-            throw new Error(
-                `${this.constructor.name}: Failed to add transaction ${txHash} to transaction pool: ${error?.message ?? String(error)}`
-            );
-        }
-    }
-
     async handleOperation(payload, connection) {
         throw new Error('handleOperation must be implemented by child class');
     }
 
 }
-export default BaseStateOperationHandler;
+export default BaseOperationHandler;

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

@@ -1,8 +1,6 @@
-import PartialOperationValidator from './PartialOperationValidator.js';
-import {ResultCode} from "../../../../../utils/constants.js";
-import SharedValidatorRejectionError from '../errors/SharedValidatorRejectionError.js';
+import PartialOperation from './base/PartialOperation.js';
 
-class PartialBootstrapDeploymentValidator extends PartialOperationValidator {
+class PartialBootstrapDeployment extends PartialOperation {
     constructor(state, selfAddress , config) {
         super(state, selfAddress , config);
     }
@@ -28,12 +26,9 @@ class PartialBootstrapDeploymentValidator extends PartialOperationValidator {
     async validateBootstrapRegistration(payload) {
         const bootstrapString = payload.bdo.bs.toString('hex');
         if (null !== await this.state.getRegisteredBootstrapEntryUnsigned(bootstrapString)) {
-            throw new SharedValidatorRejectionError(
-                ResultCode.BOOTSTRAP_ALREADY_EXISTS,
-                `Bootstrap with hash ${bootstrapString} already exists in the state. Bootstrap must be unique.`
-            );
+            throw new Error(`Bootstrap with hash ${bootstrapString} already exists in the state. Bootstrap must be unique.`);
         }
     }
 }
 
-export default PartialBootstrapDeploymentValidator;
+export default PartialBootstrapDeployment;