trac-msb 0.2.12 → 0.2.13

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 {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,6 +1,7 @@
 import b4a from 'b4a';
+import {publicKeyToAddress} from "../../../../../utils/helpers.js";
 
-class BaseOperationHandler {
+class BaseStateOperationHandler {
     #state;
     #wallet;
     #rateLimiter;
@@ -15,8 +16,8 @@ class BaseOperationHandler {
      * @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;
@@ -37,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 >= 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.`);
+        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...`
+                );
             }
         }
     }
@@ -58,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;

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

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

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

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

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

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