trac-msb 0.2.9 → 0.2.11

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

@@ -1,40 +1,158 @@
-// ProtocolSession is a per-peer (per Hyperswarm connection) wrapper that exposes the available
+// ProtocolSession is a per-peer (per Hyperswarm connection) bridge that exposes the available
 // protocol messengers (legacy JSON, v1 binary) in one place.
 //
 // Why it exists:
 // - `setupProtomuxMessages(connection)` creates Protomux channels/messages for a specific peer.
+
+import { networkMessageFactory } from '../../../messages/network/v1/networkMessageFactory.js';
+import { generateUUID } from '../../../utils/helpers.js';
+import { NETWORK_CAPABILITIES, ResultCode } from '../../../utils/constants.js';
+import { Logger } from '../../../utils/logger.js';
+
 class ProtocolSession {
     #legacyProtocol;
     #v1Protocol;
+    #preferredProtocol = null;
+    #activeProtocol = null;
+    #supportedProtocols = {
+        LEGACY: 'legacy',
+        V1: 'v1'
+    }
+    #wallet;
+    #config;
+    #capabilities;
+    #logger;
 
-    constructor(legacyProtocol, v1Protocol) {
+    constructor(legacyProtocol, v1Protocol, wallet, config) {
         // These are Protomux "message" objects (returned by channel.addMessage).
         // They are connection-scoped and expose .send(...), already wired to the channel's encoding.
         this.#legacyProtocol = legacyProtocol;
         this.#v1Protocol = v1Protocol;
+
+        this.#activeProtocol = this.#v1Protocol;
+        this.#wallet = wallet;
+        this.#config = config;
+        this.#capabilities = NETWORK_CAPABILITIES;
+        this.#logger = new Logger(config);
     }
 
-    getLegacy() {
-        return this.#legacyProtocol;
+    get preferredProtocol() {
+        return this.#preferredProtocol;
     }
 
-    getV1() {
-        return this.#v1Protocol;
+    get supportedProtocols() {
+        return this.#supportedProtocols;
     }
 
-    get(protocol) {
-        if (protocol === 'legacy') return this.#legacyProtocol;
-        if (protocol === 'v1') return this.#v1Protocol;
-        return null;
+    isProbed() {
+        return this.#preferredProtocol !== null;
     }
 
-    has(protocol) {
-        return Boolean(this.get(protocol));
+    setLegacyAsPreferredProtocol() {
+        if (this.isProbed()) {
+            // TODO:  SOMETIMES WE ARE PROBING NODE FOR MULTIPLE AMOUNT OF TIME, THIS IS BAD. WE NEED TO INVESTIGATE THIS.
+            //this.#logger.warn(`ProtocolSession: preferred protocol is already set and cannot be changed to LEGACY. Current preferred protocol: ${this.#preferredProtocol}`);
+            return;
+        }
+        this.#preferredProtocol = this.#supportedProtocols.LEGACY;
+        this.#activeProtocol = this.#legacyProtocol;
+        this.#logger.debug('ProtocolSession: set preferred protocol to LEGACY');
     }
 
-    send(message) {
-        // TODO: Support v1 messages
-        this.#legacyProtocol.send(message);
+    setV1AsPreferredProtocol() {
+        if (this.isProbed()) {
+            // TODO:  SOMETIMES WE ARE PROBING NODE FOR MULTIPLE AMOUNT OF TIME, THIS IS BAD. WE NEED TO INVESTIGATE THIS.
+            //this.#logger.warn(`ProtocolSession: preferred protocol is already set and cannot be changed to V1. Current preferred protocol: ${this.#preferredProtocol}`);
+            return;
+        }
+
+        this.#preferredProtocol = this.#supportedProtocols.V1;
+        this.#activeProtocol = this.#v1Protocol;
+        this.#logger.debug('ProtocolSession: set preferred protocol to V1');
+    }
+
+    /**
+    * Probes the peer to determine which protocol version they support/prefer. 
+    * This is needed to know if the connected peer supports the new v1 protocol
+    * or if we should fall back to legacy for this connection.
+    * 
+    * TODO: After legacy protocol is retired, we can remove the concept of "probing" and just use v1 directly.
+    * For now, this is needed to determine which protocol to use for health checks.
+    * A good future improvement would be to implement a more robust negotiation mechanism that doesn't rely on timeouts
+    * (e.g. peer sends a "hello" message indicating supported protocol versions right after connection is established).
+    */
+    async probe() {
+        if (this.isProbed()) {
+            this.#logger.warn(`ProtocolSession: preferred protocol is already set. Skipping probe. Current preferred protocol: ${this.#preferredProtocol}`);
+            return; // TODO: Consider not returning silently
+        }
+
+        try {
+            const message = await this.#buildLivenessRequest();
+            if (!this.#v1Protocol) {
+                throw new Error('ProtocolSession: v1 protocol not available for probing');
+            }
+            const result = await this.#v1Protocol.send(message);
+            if (result !== ResultCode.OK) {
+                // TODO: Think about how to handle failure result codes after legacy protocol is retired
+                this.#logger.warn(`ProtocolSession: v1 protocol probe failed with non-OK result code: ${result}`);
+                this.setLegacyAsPreferredProtocol();
+                return;
+            }
+            this.setV1AsPreferredProtocol();
+        } catch (err) {
+            this.#logger.debug(`ProtocolSession: v1 protocol probe failed, falling back to legacy. Details: ${err?.message ?? err}`);
+            this.setLegacyAsPreferredProtocol();
+        }
+    }
+
+    /**
+     * Sends a single health check message to a peer.
+     * This is used by the ValidatorHealthCheckService.
+     * @returns {Promise<ResultCode>} Result code indicating success or failure of the health check.
+     */
+    async sendHealthCheck() {
+        switch (this.#preferredProtocol) {
+            case this.#supportedProtocols.V1:
+                try {
+                    const message = await this.#buildLivenessRequest();
+                    return await this.#v1Protocol.send(message);
+                }
+                catch (err) {
+                    this.#logger.error(`ProtocolSession: v1 health check failed: ${err?.message ?? err}`);
+                    return ResultCode.UNEXPECTED_ERROR; // TODO: Consider just propagating the error instead
+                }
+            case this.#supportedProtocols.LEGACY:
+                this.#logger.warn('ProtocolSession: health check not supported on LEGACY protocol');
+                return ResultCode.OK; // TODO: Consider implementing a new result code (e.g. NOT_SUPPORTED) instead of returning OK
+            default:
+                this.#logger.warn('ProtocolSession: preferred protocol not set. Call probe() first.');
+                return ResultCode.UNSPECIFIED; // TODO: Define a more specific result code.
+        }
+    }
+
+    /**
+     * Tells whether the connected peer supports health checks, which is a feature of the v1 protocol.
+     * @returns {Boolean} True if health checks are supported in the preferred protocol, false otherwise.
+     */
+    isHealthCheckSupported() {
+        if (this.#preferredProtocol === null) {
+            throw new Error('ProtocolSession: preferred protocol not set. Call probe() first.');
+        }
+        return this.#preferredProtocol === this.#supportedProtocols.V1;
+    }
+
+    // TODO: Consider moving this method to be used only in V1 internally, just like 'encode'
+    decode(message) {
+        return this.#activeProtocol.decode(message);
+    }
+
+    async send(message) {
+        return this.#activeProtocol.send(message);
+    }
+
+    sendAndForget(message) {
+        this.#activeProtocol.sendAndForget(message);
     }
 
     close() {
@@ -42,7 +160,7 @@ class ProtocolSession {
             try {
                 this.#legacyProtocol.close();
             } catch (e) {
-                console.error('Failed to close legacy channel:', e); // TODO: Think about throwing instead
+                this.#logger.error(`ProtocolSession: failed to close legacy channel: ${e?.message ?? e}`); // TODO: Think about throwing instead
             }
         }
 
@@ -50,10 +168,19 @@ class ProtocolSession {
             try {
                 this.#v1Protocol.close();
             } catch (e) {
-                console.error('Failed to close v1 channel:', e); // TODO: Think about throwing instead
+                this.#logger.error(`ProtocolSession: failed to close v1 channel: ${e?.message ?? e}`); // TODO: Think about throwing instead
             }
         }
     }
+
+    async #buildLivenessRequest() {
+        if (!this.#wallet || !this.#config) {
+            throw new Error('ProtocolSession: wallet/config not set for liveness request');
+        }
+        const requestId = generateUUID();
+        return await networkMessageFactory(this.#wallet, this.#config)
+            .buildLivenessRequest(requestId, this.#capabilities);
+    }
 }
 
 export default ProtocolSession;

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

@@ -1,18 +1,20 @@
 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, config) {
-        super(router, connection, config);
-        this.#config = config;
+    constructor(router, connection, pendingRequestService, config) {
+        super(router, connection, pendingRequestService, config);
         this.#router = router;
+        this.#publicKeyHex = connection.remotePublicKey.toString('hex');
+        this.#pendingRequestService = pendingRequestService;
         this.init(connection);
     }
 
@@ -30,30 +32,47 @@ 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: 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');
+            onmessage: (incomingMessage) => {
+                this.#router.route(incomingMessage, connection).catch((err) => {
+                    console.error(`V1Protocol: unhandled router error: ${err.message}`);
+                    try {
+                        connection.end();
+                    } catch {
                     }
-                } catch (error) {
-                    console.error(`NetworkMessages: Failed to handle incoming v1 message: ${error.message}`);
-                }
+                });
             }
         });
     }
 
-    send(message) {
-        this.#session.send(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));
     }
 
     close() {

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

@@ -0,0 +1,88 @@
+import { ResultCode } from '../../../utils/constants.js';
+
+// TODO: Consider how to behave with ResultCode.UNSPECIFIED
+
+export const SENDER_ACTION = Object.freeze({
+    UNDEFINED: 'UNDEFINED',
+    SUCCESS: 'SUCCESS',
+    ROTATE: 'ROTATE',
+    NO_ROTATE: 'NO_ROTATE',
+});
+
+const SUCCESS_CODES = new Set([
+    ResultCode.OK,
+]);
+
+const ROTATE_CODES = new Set([
+    ResultCode.UNSPECIFIED,
+    ResultCode.INVALID_PAYLOAD,
+    ResultCode.RATE_LIMITED,
+    ResultCode.SIGNATURE_INVALID,
+    ResultCode.UNEXPECTED_ERROR,
+    ResultCode.TIMEOUT,
+    ResultCode.NODE_HAS_NO_WRITE_ACCESS,
+    ResultCode.TX_ACCEPTED_PROOF_UNAVAILABLE,
+    ResultCode.NODE_OVERLOADED,
+    ResultCode.OPERATION_TYPE_UNKNOWN,
+    ResultCode.SCHEMA_VALIDATION_FAILED,
+    ResultCode.REQUESTER_ADDRESS_INVALID,
+    ResultCode.REQUESTER_PUBLIC_KEY_INVALID,
+    ResultCode.TX_HASH_MISMATCH,
+    ResultCode.TX_SIGNATURE_INVALID,
+    ResultCode.TX_EXPIRED,
+    ResultCode.TX_ALREADY_EXISTS,
+    ResultCode.OPERATION_ALREADY_COMPLETED,
+    ResultCode.REQUESTER_NOT_FOUND,
+    ResultCode.INSUFFICIENT_FEE_BALANCE,
+    ResultCode.EXTERNAL_BOOTSTRAP_EQUALS_MSB_BOOTSTRAP,
+    ResultCode.SELF_VALIDATION_FORBIDDEN,
+    ResultCode.ROLE_NODE_ENTRY_NOT_FOUND,
+    ResultCode.ROLE_NODE_ALREADY_WRITER,
+    ResultCode.ROLE_NODE_NOT_WHITELISTED,
+    ResultCode.ROLE_NODE_NOT_WRITER,
+    ResultCode.ROLE_NODE_IS_INDEXER,
+    ResultCode.ROLE_ADMIN_ENTRY_MISSING,
+    ResultCode.ROLE_INVALID_RECOVERY_CASE,
+    ResultCode.ROLE_UNKNOWN_OPERATION,
+    ResultCode.ROLE_INVALID_WRITER_KEY,
+    ResultCode.ROLE_INSUFFICIENT_FEE_BALANCE,
+    ResultCode.MSB_BOOTSTRAP_MISMATCH,
+    ResultCode.EXTERNAL_BOOTSTRAP_NOT_DEPLOYED,
+    ResultCode.EXTERNAL_BOOTSTRAP_TX_MISSING,
+    ResultCode.EXTERNAL_BOOTSTRAP_MISMATCH,
+    ResultCode.BOOTSTRAP_ALREADY_EXISTS,
+    ResultCode.TRANSFER_RECIPIENT_ADDRESS_INVALID,
+    ResultCode.TRANSFER_RECIPIENT_PUBLIC_KEY_INVALID,
+    ResultCode.TRANSFER_AMOUNT_TOO_LARGE,
+    ResultCode.TRANSFER_SENDER_NOT_FOUND,
+    ResultCode.TRANSFER_INSUFFICIENT_BALANCE,
+    ResultCode.TRANSFER_RECIPIENT_BALANCE_OVERFLOW,
+    ResultCode.TX_HASH_INVALID_FORMAT,
+    ResultCode.INTERNAL_ENQUEUE_VALIDATION_FAILED,
+    ResultCode.TX_COMMITTED_RECEIPT_MISSING,
+    ResultCode.VALIDATOR_RESPONSE_TX_TYPE_INVALID,
+    ResultCode.VALIDATOR_RESPONSE_TX_TYPE_UNKNOWN,
+    ResultCode.VALIDATOR_RESPONSE_TX_TYPE_UNSUPPORTED,
+    ResultCode.VALIDATOR_RESPONSE_SCHEMA_INVALID,
+    ResultCode.PENDING_REQUEST_MISSING_TX_DATA,
+    ResultCode.PROOF_PAYLOAD_MISMATCH,
+    ResultCode.VALIDATOR_WRITER_KEY_NOT_REGISTERED,
+    ResultCode.VALIDATOR_ADDRESS_MISMATCH,
+    ResultCode.VALIDATOR_NODE_ENTRY_NOT_FOUND,
+    ResultCode.VALIDATOR_NODE_NOT_WRITER,
+    ResultCode.VALIDATOR_WRITER_KEY_MISMATCH,
+    ResultCode.VALIDATOR_TX_OBJECT_INVALID,
+    ResultCode.VALIDATOR_VA_MISSING,
+    ResultCode.TX_INVALID_PAYLOAD
+]);
+
+const NO_ROTATE_CODES = new Set([
+    ResultCode.TX_ALREADY_PENDING,
+]);
+
+export function resultToValidatorAction(resultCode) {
+    if (SUCCESS_CODES.has(resultCode)) return SENDER_ACTION.SUCCESS;
+    if (ROTATE_CODES.has(resultCode)) return SENDER_ACTION.ROTATE;
+    if (NO_ROTATE_CODES.has(resultCode)) return SENDER_ACTION.NO_ROTATE;
+    return SENDER_ACTION.UNDEFINED;
+}

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

@@ -1,13 +1,12 @@
 import b4a from "b4a";
-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 _ 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 { 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;
@@ -18,29 +17,32 @@ class NetworkMessageRouter {
      * @param {PeerWallet} wallet
      * @param {TransactionRateLimiterService} rateLimiterService
      * @param {TransactionPoolService} txPoolService
-     * @param {ConnectionManager} connectionManager
-     * @param {object} config
+     * @param {Config} config
      **/
-    constructor(state, wallet, rateLimiterService, txPoolService, connectionManager, config) {
+    constructor(state, wallet, rateLimiterService, txPoolService, config) {
         this.#config = config;
 
         this.#handlers = {
-            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),
+            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),
+
         }
     }
 
-    // NOTE: messageProtomux can be deleted, ad this is a session, and we can extract this from connection
-    async route(incomingMessage, connection, messageProtomux) {
+    async route(incomingMessage, connection) {
+        this.#preValidate(incomingMessage);
         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, messageProtomux, connection, channelString);
+            await this.#handlers.get.handle(incomingMessage, connection, channelString);
         }
         else if (this.#isResponse(incomingMessage)) {
-            await this.#handlers.response.handle(incomingMessage, connection, channelString);
+            await this.#handlers.response.handle(incomingMessage, channelString);
         }
         else if (this.#isRoleAccessOperation(incomingMessage)) {
             await this.#handlers.roleTransaction.handle(incomingMessage, connection);
@@ -54,14 +56,18 @@ 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/{shared/handlers/base/BaseOperationHandler.js → legacy/handlers/BaseStateOperationHandler.js}

@@ -1,7 +1,7 @@
 import b4a from 'b4a';
-import {MAX_PARTIAL_TX_PAYLOAD_BYTE_SIZE, TRANSACTION_POOL_SIZE} from '../../../../../../utils/constants.js';
+import {publicKeyToAddress} from "../../../../../utils/helpers.js";
 
-class BaseOperationHandler {
+class BaseStateOperationHandler {
     #state;
     #wallet;
     #rateLimiter;
@@ -13,11 +13,11 @@ class BaseOperationHandler {
      * @param {PeerWallet} wallet
      * @param {TransactionRateLimiterService} rateLimiter
      * @param {TransactionPoolService} txPoolService
-     * @param {object} config
+     * @param {Config} config
      **/
     constructor(state, wallet, rateLimiter, txPoolService, config) {
-        if (new.target === BaseOperationHandler) {
-            throw new Error('BaseOperationHandler is abstract and cannot be instantiated directly');
+        if (new.target === BaseStateOperationHandler) {
+            throw new Error('BaseStateOperationHandler is abstract and cannot be instantiated directly');
         }
         this.#state = state;
         this.#wallet = wallet;
@@ -30,7 +30,7 @@ class BaseOperationHandler {
         // 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;
@@ -38,18 +38,18 @@ class BaseOperationHandler {
             throw new Error('OperationHandler: State is not writable or is an indexer without admin privileges.');
         }
 
-        if (this.#txPoolService.tx_pool.length >= TRANSACTION_POOL_SIZE) {
-            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.`);
+        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.#config.disableRateLimit) {
-            const shouldDisconnect = this.#rateLimiter.handleRateLimit(connection);
+            const shouldDisconnect = this.#rateLimiter.legacyHandleRateLimit(connection);
             if (shouldDisconnect) {
-                throw new Error(`OperationHandler: Rate limit exceeded for peer ${b4a.toString(connection.remotePublicKey, 'hex')}. Disconnecting...`);
+                throw new Error(
+                    `OperationHandler: Rate limit exceeded for ${publicKeyToAddress(connection.remotePublicKey, this.#config)}. Disconnecting...`
+                );
             }
         }
     }
@@ -59,9 +59,19 @@ class BaseOperationHandler {
         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 BaseOperationHandler;
+export default BaseStateOperationHandler;

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

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

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

@@ -0,0 +1,23 @@
+import ValidatorResponse from '../validators/ValidatorResponse.js';
+
+class LegacyResponseHandler {
+    #responseValidator;
+
+    constructor(state, wallet, config) {
+        this.#responseValidator = new ValidatorResponse(state, wallet, config);
+
+    }
+
+    async handle(message, channelString) {
+        await this.#handleValidatorResponse(message, channelString);
+    }
+
+    async #handleValidatorResponse(message, channelString) {
+        const isValid = await this.#responseValidator.validate(message, channelString);
+        if (!isValid) {
+            throw new Error("Validator response verification failed");
+        }
+    }
+}
+
+export default LegacyResponseHandler;