trac-msb 0.2.12 → 0.2.13

package/src/core/network/protocols/shared/errors/SharedValidatorRejectionError.js

@@ -0,0 +1,27 @@
+import {V1ProtocolError} from '../../v1/V1ProtocolError.js';
+
+/**
+ * Shared validator rejection error.
+ *
+ * Used by shared validators in `src/core/network/protocols/shared/validators/**` so they can
+ * reject remote peer input with a stable `resultCode`.
+ *
+ * Note: this currently extends `V1ProtocolError` so the v1 protocol can consistently treat shared
+ * validator rejections as typed protocol errors. Legacy protocol codepaths remain compatible because
+ * this is still an `Error` and preserves `.message`.
+ *
+ * Default `endConnection = true` because shared-validator rejections are typically triggered
+ * by invalid/malicious peer payloads and should terminate the peer connection after responding.
+ */
+export class SharedValidatorRejectionError extends V1ProtocolError {
+    /**
+     * @param {number} resultCode Stable rejection reason (a `ResultCode` value).
+     * @param {string} message Human-readable error message.
+     * @param {boolean} [endConnection=true] Whether the transport should end the connection after responding.
+     */
+    constructor(resultCode, message, endConnection = true) {
+        super(resultCode, message, endConnection);
+    }
+}
+
+export default SharedValidatorRejectionError;

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

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

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

@@ -1,18 +1,19 @@
 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/applyOperations.js';
+import Check from '../../../../../utils/check.js';
+import {bufferToAddress} from "../../../../state/utils/address.js";
+import {createMessage} from "../../../../../utils/buffer.js";
+import {OperationType, ResultCode} from "../../../../../utils/constants.js";
+import {bufferToBigInt} from "../../../../../utils/amountSerialization.js";
+import {FEE} from "../../../../state/utils/transaction.js";
+import * as operationsUtils from '../../../../../utils/applyOperations.js';
+import SharedValidatorRejectionError from '../errors/SharedValidatorRejectionError.js';
 
 const MAX_AMOUNT = BigInt('0xffffffffffffffffffffffffffffffff');
 const FEE_BIGINT = bufferToBigInt(FEE);
 const PUBLIC_KEY_LENGTH = 32;
 
-class PartialOperation {
+class PartialOperationValidator {
     #state;
     #check;
     #config
@@ -36,18 +37,18 @@ class PartialOperation {
     }
 
     async validate(payload) {
-        throw new Error("Method 'validate()' must be implemented.");
+        throw new SharedValidatorRejectionError(ResultCode.UNEXPECTED_ERROR, "Method 'validate()' must be implemented.");
     }
 
     isPayloadSchemaValid(payload) {
         if (!payload || !payload.type) {
-            throw new Error('Payload or payload type is missing.');
+            throw new SharedValidatorRejectionError(ResultCode.TX_INVALID_PAYLOAD, 'Payload or payload type is missing.');
         }
 
         const selectedValidator = this.#selectCheckSchemaValidator(payload.type);
         const isPayloadValid = selectedValidator(payload);
         if (!isPayloadValid) {
-            throw new Error(`Payload is invalid.`);
+            throw new SharedValidatorRejectionError(ResultCode.SCHEMA_VALIDATION_FAILED, 'Payload is invalid.');
         }
     }
 
@@ -64,21 +65,24 @@ class PartialOperation {
             case OperationType.TRANSFER:
                 return this.check.validateTransferOperation.bind(this.check);
             default:
-                throw new Error(`Unknown operation type: ${type}`);
+                throw new SharedValidatorRejectionError(
+                    ResultCode.OPERATION_TYPE_UNKNOWN,
+                    `Unknown operation type: ${type}`
+                );
         }
     }
 
     validateRequesterAddress(payload) {
         const incomingAddress = bufferToAddress(payload.address, this.#config.addressPrefix);
         if (!incomingAddress) {
-            throw new Error('Invalid requesting address in payload.');
+            throw new SharedValidatorRejectionError(ResultCode.REQUESTER_ADDRESS_INVALID, 'Invalid requesting address in payload.');
         }
 
         const incomingPublicKey = PeerWallet.decodeBech32mSafe(incomingAddress);
 
         // TODO: We can add check if public key belongs to the Ed25519 curve. Validate signature already checks that but it would be amazing to catch it earlier.
         if (!incomingPublicKey || incomingPublicKey.length !== PUBLIC_KEY_LENGTH) {
-            throw new Error('Invalid requesting public key in payload.');
+            throw new SharedValidatorRejectionError(ResultCode.REQUESTER_PUBLIC_KEY_INVALID, 'Invalid requesting public key in payload.');
         }
     }
 
@@ -127,7 +131,10 @@ class PartialOperation {
                     OperationType.TRANSFER
                 ];
             default:
-                throw new Error(`Unknown operation type: ${payload.type}`);
+                throw new SharedValidatorRejectionError(
+                    ResultCode.OPERATION_TYPE_UNKNOWN,
+                    `Unknown operation type: ${payload.type}`
+                );
         }
     }
 
@@ -143,11 +150,14 @@ class PartialOperation {
         const messageHash = await PeerWallet.blake3(message);
         const payloadHash = operation.tx;
         if (!b4a.equals(payloadHash, messageHash)) {
-            throw new Error('Regenerated transaction does not match incoming transaction in payload.');
+            throw new SharedValidatorRejectionError(
+                ResultCode.TX_HASH_MISMATCH,
+                'Regenerated transaction does not match incoming transaction in payload.'
+            );
         }
 
         if (!PeerWallet.verify(incomingSignature, messageHash, incomingPublicKey)) {
-            throw new Error('Invalid signature in payload.');
+            throw new SharedValidatorRejectionError(ResultCode.TX_SIGNATURE_INVALID, 'Invalid signature in payload.');
         }
     }
 
@@ -158,7 +168,7 @@ class PartialOperation {
         const incomingTxv = operation.txv
 
         if (!b4a.equals(currentTxv, incomingTxv)) {
-            throw new Error(`Transaction has expired.`);
+            throw new SharedValidatorRejectionError(ResultCode.TX_EXPIRED, 'Transaction has expired.');
         }
     }
 
@@ -169,7 +179,10 @@ class PartialOperation {
         const txHex = tx.toString('hex');
 
         if (await this.state.get(txHex) !== null) {
-            throw new Error(`Transaction with hash ${txHex} already exists in the state.`);
+            throw new SharedValidatorRejectionError(
+                ResultCode.TX_ALREADY_EXISTS,
+                `Transaction with hash ${txHex} already exists in the state.`
+            );
         }
     }
 
@@ -180,7 +193,10 @@ class PartialOperation {
 
         const condition = va === undefined && vn === undefined && vs === undefined
         if (!condition) {
-            throw new Error('Transfer operation must not be completed already (va, vn, vs must be undefined).');
+            throw new SharedValidatorRejectionError(
+                ResultCode.OPERATION_ALREADY_COMPLETED,
+                'Transfer operation must not be completed already (va, vn, vs must be undefined).'
+            );
         }
     }
 
@@ -194,12 +210,12 @@ class PartialOperation {
         }
 
         if (!requesterEntry) {
-            throw new Error('Requester address not found in state');
+            throw new SharedValidatorRejectionError(ResultCode.REQUESTER_NOT_FOUND, 'Requester address not found in state');
         }
 
         const requesterBalance = bufferToBigInt(requesterEntry.balance);
         if (requesterBalance < FEE_BIGINT) {
-            throw new Error('Insufficient balance to cover transaction fee.');
+            throw new SharedValidatorRejectionError(ResultCode.INSUFFICIENT_FEE_BALANCE, 'Insufficient balance to cover transaction fee.');
         }
     }
 
@@ -209,7 +225,10 @@ class PartialOperation {
         const operation = payload[operationKey];
         const bs = operation.bs;
         if (b4a.equals(this.#config.bootstrap, bs)) {
-            throw new Error(`External bootstrap is the same as MSB bootstrap: ${bs.toString('hex')}`);
+            throw new SharedValidatorRejectionError(
+                ResultCode.EXTERNAL_BOOTSTRAP_EQUALS_MSB_BOOTSTRAP,
+                `External bootstrap is the same as MSB bootstrap: ${bs.toString('hex')}`
+            );
         }
     }
 
@@ -223,10 +242,13 @@ class PartialOperation {
 
         const requesterAddress = bufferToAddress(payload.address, this.#config.addressPrefix);
         if (this.#selfAddress === requesterAddress) {
-            throw new Error('Requester address cannot be the same as the validator wallet address.');
+            throw new SharedValidatorRejectionError(
+                ResultCode.SELF_VALIDATION_FORBIDDEN,
+                'Requester address cannot be the same as the validator wallet address.'
+            );
         }
     }
 
 }
 
-export default PartialOperation;
+export default PartialOperationValidator;

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

@@ -1,10 +1,11 @@
 import b4a from 'b4a';
-import {OperationType} from "../../../../../utils/constants.js";
+import {OperationType, ResultCode} from "../../../../../utils/constants.js";
 import {bufferToAddress} from "../../../../state/utils/address.js";
-import PartialOperation from './base/PartialOperation.js';
+import PartialOperationValidator from './PartialOperationValidator.js';
 import {bufferToBigInt} from "../../../../../utils/amountSerialization.js";
+import SharedValidatorRejectionError from '../errors/SharedValidatorRejectionError.js';
 
-class PartialRoleAccess extends PartialOperation {
+class PartialRoleAccessValidator extends PartialOperationValidator {
     #config;
 
     constructor(state, selfAddress, config) {
@@ -42,17 +43,26 @@ class PartialRoleAccess extends PartialOperation {
             const nodeAddress = bufferToAddress(payload.address, this.#config.addressPrefix);
             const nodeEntry = await this.state.getNodeEntry(nodeAddress);
             if (!nodeEntry) {
-                throw new Error(`Node with address ${nodeAddress} entry does not exist.`);
+                throw new SharedValidatorRejectionError(
+                    ResultCode.ROLE_NODE_ENTRY_NOT_FOUND,
+                    `Node with address ${nodeAddress} entry does not exist.`
+                );
             }
 
             const isNodeAlreadyWriter = nodeEntry.isWriter;
             if (isNodeAlreadyWriter) {
-                throw new Error(`Node with address ${nodeAddress} is already a writer.`);
+                throw new SharedValidatorRejectionError(
+                    ResultCode.ROLE_NODE_ALREADY_WRITER,
+                    `Node with address ${nodeAddress} is already a writer.`
+                );
             }
 
             const isNodeWhitelisted = nodeEntry.isWhitelisted;
             if (!isNodeWhitelisted) {
-                throw new Error(`Node with address ${nodeAddress} is not whitelisted.`);
+                throw new SharedValidatorRejectionError(
+                    ResultCode.ROLE_NODE_NOT_WHITELISTED,
+                    `Node with address ${nodeAddress} is not whitelisted.`
+                );
             }
             return;
 
@@ -60,24 +70,33 @@ class PartialRoleAccess extends PartialOperation {
             const nodeAddress = bufferToAddress(payload.address, this.#config.addressPrefix);
             const nodeEntry = await this.state.getNodeEntry(nodeAddress);
             if (!nodeEntry) {
-                throw new Error(`Node with address ${nodeAddress} entry does not exist.`);
+                throw new SharedValidatorRejectionError(
+                    ResultCode.ROLE_NODE_ENTRY_NOT_FOUND,
+                    `Node with address ${nodeAddress} entry does not exist.`
+                );
             }
 
             const isAlreadyWriter = nodeEntry.isWriter;
             if (!isAlreadyWriter) {
-                throw new Error(`Node with address ${nodeAddress} is not a writer.`);
+                throw new SharedValidatorRejectionError(
+                    ResultCode.ROLE_NODE_NOT_WRITER,
+                    `Node with address ${nodeAddress} is not a writer.`
+                );
             }
 
             const isAlreadyIndexer = nodeEntry.isIndexer;
             if (isAlreadyIndexer) {
-                throw new Error(`Node with address ${nodeAddress} is an indexer.`);
+                throw new SharedValidatorRejectionError(
+                    ResultCode.ROLE_NODE_IS_INDEXER,
+                    `Node with address ${nodeAddress} is an indexer.`
+                );
             }
             return;
 
         } else if (type === OperationType.ADMIN_RECOVERY) {
             const adminEntry = await this.state.getAdminEntry();
             if (!adminEntry) {
-                throw new Error('Admin entry does not exist.');
+                throw new SharedValidatorRejectionError(ResultCode.ROLE_ADMIN_ENTRY_MISSING, 'Admin entry does not exist.');
             }
 
             const adminAddressBuffer = payload.address;
@@ -87,20 +106,29 @@ class PartialRoleAccess extends PartialOperation {
                 !b4a.equals(payload.rao.iw, adminEntry.wk)
             );
             if (!isRecoveryCase) {
-                throw new Error(`Node with address ${adminAddress} is not a valid recovery case.`);
+                throw new SharedValidatorRejectionError(
+                    ResultCode.ROLE_INVALID_RECOVERY_CASE,
+                    `Node with address ${adminAddress} is not a valid recovery case.`
+                );
             }
 
             return;
         }
 
-        throw new Error(`Unknown role access operation type: ${type}`);
+        throw new SharedValidatorRejectionError(
+            ResultCode.ROLE_UNKNOWN_OPERATION,
+            `Unknown role access operation type: ${type}`
+        );
     }
 
     async validateWriterKey(payload) {
         const requesterAddress = bufferToAddress(payload.address, this.#config.addressPrefix);
         const nodeEntry = await this.state.getNodeEntry(requesterAddress);
         if (!nodeEntry) {
-            throw new Error(`Node entry not found for address ${requesterAddress}`);
+            throw new SharedValidatorRejectionError(
+                ResultCode.REQUESTER_NOT_FOUND,
+                `Node entry not found for address ${requesterAddress}`
+            );
         }
 
         const writerKey = payload.rao.iw.toString('hex');
@@ -111,7 +139,10 @@ class PartialRoleAccess extends PartialOperation {
             const isOwner = b4a.equals(addressFromRegisteredWritingKey, payload.address);
 
             if (!isCurrentWk || !isOwner) {
-                throw new Error('Invalid writer key: either not owned by requester or different from assigned key');
+                throw new SharedValidatorRejectionError(
+                    ResultCode.ROLE_INVALID_WRITER_KEY,
+                    'Invalid writer key: either not owned by requester or different from assigned key'
+                );
             }
         }
     }
@@ -126,15 +157,18 @@ class PartialRoleAccess extends PartialOperation {
         }
 
         if (!requesterEntry) {
-            throw new Error('Requester address not found in state');
+            throw new SharedValidatorRejectionError(ResultCode.REQUESTER_NOT_FOUND, 'Requester address not found in state');
         }
         const requesterBalance = bufferToBigInt(requesterEntry.balance);
 
         const requiredBalance = this.fee * 11n;
         if (requesterBalance < requiredBalance) {
-            throw new Error('Insufficient requester balance to cover role access operation FEE.');
+            throw new SharedValidatorRejectionError(
+                ResultCode.ROLE_INSUFFICIENT_FEE_BALANCE,
+                'Insufficient requester balance to cover role access operation FEE.'
+            );
         }
     }
 }
 
-export default PartialRoleAccess;
+export default PartialRoleAccessValidator;

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

@@ -1,9 +1,11 @@
 import b4a from 'b4a';
 import {safeDecodeApplyOperation} from "../../../../../utils/protobuf/operationHelpers.js";
 import deploymentEntryUtils from "../../../../state/utils/deploymentEntry.js";
-import PartialOperation from './base/PartialOperation.js';
+import PartialOperationValidator from './PartialOperationValidator.js';
+import {ResultCode} from "../../../../../utils/constants.js";
+import SharedValidatorRejectionError from '../errors/SharedValidatorRejectionError.js';
 
-class PartialTransaction extends PartialOperation {
+class PartialTransactionValidator extends PartialOperationValidator {
     #config
 
     constructor(state, selfAddress, config) {
@@ -32,14 +34,20 @@ class PartialTransaction extends PartialOperation {
 
     validateMsbBootstrap(payload) {
         if (!b4a.equals(this.#config.bootstrap, payload.txo.mbs)) {
-            throw new Error(`Declared MSB bootstrap is different than network bootstrap in transaction operation: ${payload.txo.mbs.toString('hex')}`);
+            throw new SharedValidatorRejectionError(
+                ResultCode.MSB_BOOTSTRAP_MISMATCH,
+                `Declared MSB bootstrap is different than network bootstrap in transaction operation: ${payload.txo.mbs.toString('hex')}`
+            );
         }
     }
 
     async validateIfExternalBootstrapHasBeenDeployed(payload) {
         const externalBootstrapResult = await this.state.getRegisteredBootstrapEntry(payload.txo.bs.toString('hex'));
         if (externalBootstrapResult === null) {
-            throw new Error(`External bootstrap with hash ${payload.txo.bs.toString('hex')} is not registered as deployment entry.`);
+            throw new SharedValidatorRejectionError(
+                ResultCode.EXTERNAL_BOOTSTRAP_NOT_DEPLOYED,
+                `External bootstrap with hash ${payload.txo.bs.toString('hex')} is not registered as deployment entry.`
+            );
         }
 
         const decodedPayload = deploymentEntryUtils.decode(externalBootstrapResult, this.#config.addressLength);
@@ -47,17 +55,23 @@ class PartialTransaction extends PartialOperation {
         const getBootstrapTransactionTxPayload = await this.state.get(txHash.toString('hex'));
 
         if (getBootstrapTransactionTxPayload === null) {
-            throw new Error(`External bootstrap is not registered as usual tx ${externalBootstrapResult.toString('hex')}: ${payload}`);
+            throw new SharedValidatorRejectionError(
+                ResultCode.EXTERNAL_BOOTSTRAP_TX_MISSING,
+                `External bootstrap is not registered as usual tx ${externalBootstrapResult.toString('hex')}: ${payload}`
+            );
         }
 
         const decodedBootstrapDeployment = safeDecodeApplyOperation(getBootstrapTransactionTxPayload)
 
         // edge case
         if (!b4a.equals(decodedBootstrapDeployment.bdo.bs, payload.txo.bs)) {
-            throw new Error(`External bootstrap does not match the one in the transaction payload: ${decodedBootstrapDeployment.bdo.bs.toString('hex')} !== ${payload.txo.bs.toString('hex')}`);
+            throw new SharedValidatorRejectionError(
+                ResultCode.EXTERNAL_BOOTSTRAP_MISMATCH,
+                `External bootstrap does not match the one in the transaction payload: ${decodedBootstrapDeployment.bdo.bs.toString('hex')} !== ${payload.txo.bs.toString('hex')}`
+            );
         }
     }
 
 }
 
-export default PartialTransaction;
+export default PartialTransactionValidator;

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

@@ -2,9 +2,11 @@ import PeerWallet from 'trac-wallet';
 
 import {bufferToAddress} from "../../../../state/utils/address.js";
 import {bufferToBigInt} from "../../../../../utils/amountSerialization.js";
-import PartialOperation from './base/PartialOperation.js';
+import {ResultCode} from "../../../../../utils/constants.js";
+import PartialOperationValidator from './PartialOperationValidator.js';
+import SharedValidatorRejectionError from '../errors/SharedValidatorRejectionError.js';
 
-class PartialTransfer extends PartialOperation {
+class PartialTransferValidator extends PartialOperationValidator {
     #config
 
     constructor(state, selfAddress, config) {
@@ -31,12 +33,18 @@ class PartialTransfer extends PartialOperation {
     #validateRecipientAddress(payload) {
         const incomingAddress = bufferToAddress(payload.tro.to, this.#config.addressPrefix);
         if (!incomingAddress) {
-            throw new Error('Invalid recipient address in transfer payload.');
+            throw new SharedValidatorRejectionError(
+                ResultCode.TRANSFER_RECIPIENT_ADDRESS_INVALID,
+                'Invalid recipient address in transfer payload.'
+            );
         }
 
         const incomingPublicKey = PeerWallet.decodeBech32mSafe(incomingAddress);
         if (incomingPublicKey === null) {
-            throw new Error('Invalid recipient public key in transfer payload.');
+            throw new SharedValidatorRejectionError(
+                ResultCode.TRANSFER_RECIPIENT_PUBLIC_KEY_INVALID,
+                'Invalid recipient public key in transfer payload.'
+            );
         }
 
     }
@@ -47,7 +55,10 @@ class PartialTransfer extends PartialOperation {
 
         const transferAmount = bufferToBigInt(payload.tro.am);
         if (transferAmount > this.max_amount) {
-            throw new Error('Transfer amount exceeds maximum allowed value');
+            throw new SharedValidatorRejectionError(
+                ResultCode.TRANSFER_AMOUNT_TOO_LARGE,
+                'Transfer amount exceeds maximum allowed value'
+            );
         }
 
         const isSelfTransfer = senderAddress === recipientAddress;
@@ -55,12 +66,15 @@ class PartialTransfer extends PartialOperation {
 
         const senderEntry = await this.state.getNodeEntryUnsigned(senderAddress);
         if (!senderEntry) {
-            throw new Error('Sender account not found');
+            throw new SharedValidatorRejectionError(ResultCode.TRANSFER_SENDER_NOT_FOUND, 'Sender account not found');
         }
 
         const senderBalance = bufferToBigInt(senderEntry.balance);
         if (!(senderBalance >= totalDeductedAmount)) {
-            throw new Error('Insufficient balance for transfer' + (isSelfTransfer ? ' fee' : ' + fee'));
+            throw new SharedValidatorRejectionError(
+                ResultCode.TRANSFER_INSUFFICIENT_BALANCE,
+                'Insufficient balance for transfer' + (isSelfTransfer ? ' fee' : ' + fee')
+            );
         }
 
         if (!isSelfTransfer) {
@@ -69,11 +83,14 @@ class PartialTransfer extends PartialOperation {
                 const recipientBalance = bufferToBigInt(recipientEntry.balance);
                 const newRecipientBalance = recipientBalance + transferAmount;
                 if (newRecipientBalance > this.max_amount) {
-                    throw new Error('Transfer would cause recipient balance to exceed maximum allowed value');
+                    throw new SharedValidatorRejectionError(
+                        ResultCode.TRANSFER_RECIPIENT_BALANCE_OVERFLOW,
+                        'Transfer would cause recipient balance to exceed maximum allowed value'
+                    );
                 }
             }
         }
     }
 }
 
-export default PartialTransfer;
+export default PartialTransferValidator;

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

@@ -1,15 +1,99 @@
-import { MessageHeader } from '../../../../utils/protobuf/network.cjs';
+import { decodeV1networkOperation } from '../../../../utils/protobuf/operationHelpers.js'
+import b4a from 'b4a'
+import { NetworkOperationType, V1_PROTOCOL_PAYLOAD_MAX_SIZE } from '../../../../utils/constants.js'
+import { publicKeyToAddress } from '../../../../utils/helpers.js'
+import V1LivenessOperationHandler from './handlers/V1LivenessOperationHandler.js'
+import V1BroadcastTransactionOperationHandler from './handlers/V1BroadcastTransactionOperationHandler.js'
 
 class NetworkMessageRouterV1 {
-    #config;
+    #config
+    #livenessRequestHandler
+    #broadcastTransactionHandler
 
-    constructor(config) {
-        this.#config = config;
+    constructor(
+        state,
+        wallet,
+        rateLimiterService,
+        txPoolService,
+        pendingRequestsService,
+        transactionCommitService,
+        config
+    ) {
+        this.#config = config
+        this.#livenessRequestHandler = new V1LivenessOperationHandler(
+            wallet,
+            rateLimiterService,
+            pendingRequestsService,
+            config
+        );
+        this.#broadcastTransactionHandler = new V1BroadcastTransactionOperationHandler(
+            state,
+            wallet,
+            rateLimiterService,
+            txPoolService,
+            pendingRequestsService,
+            transactionCommitService,
+            config
+        );
     }
 
-    async route(incomingMessage) {
-        MessageHeader.decode(incomingMessage);
+    async route(incomingMessage, connection) {
+        if (!this.#preValidate(incomingMessage)) {
+            this.#disconnect(connection, 'Pre-validation failed for incoming V1 message')
+            return;
+        }
+        let decodedMessage;
+
+        try {
+            decodedMessage = decodeV1networkOperation(incomingMessage)
+        } catch (error) {
+            this.#disconnect(connection, `Failed to decode incoming V1 message: ${error.message}`)
+            return;
+        }
+
+        // TODO: Decide if we really need to check decodedMessage.type here, since this is done
+        // again in the next switch statement
+        if (!decodedMessage || !Number.isInteger(decodedMessage.type) || decodedMessage.type <= 0) {
+            this.#disconnect(connection, `Invalid V1 message type: ${decodedMessage?.type}`)
+            return;
+        }
+
+        // We received a v1 message, so we set the connection protocol accordingly
+        connection.protocolSession.setV1AsPreferredProtocol()
+
+        try {
+            switch (decodedMessage.type) {
+                case NetworkOperationType.LIVENESS_REQUEST:
+                    await this.#livenessRequestHandler.handleRequest(decodedMessage, connection);
+                    break;
+                case NetworkOperationType.LIVENESS_RESPONSE:
+                    await this.#livenessRequestHandler.handleResponse(decodedMessage, connection);
+                    break;
+
+                case NetworkOperationType.BROADCAST_TRANSACTION_REQUEST:
+                    await this.#broadcastTransactionHandler.handleRequest(decodedMessage, connection);
+                    break;
+
+                case NetworkOperationType.BROADCAST_TRANSACTION_RESPONSE:
+                    await this.#broadcastTransactionHandler.handleResponse(decodedMessage, connection);
+                    break;
+                default:
+                    this.#disconnect(connection, `Unsupported V1 message type: ${decodedMessage.type}`)
+            }
+        } catch (error) {
+            this.#disconnect(connection, `Unhandled error while routing V1 message: ${error.message}`)
+        }
+    }
+
+    #preValidate(incomingMessage) {
+        return !(!incomingMessage || !b4a.isBuffer(incomingMessage) || incomingMessage.length === 0 || incomingMessage.length > V1_PROTOCOL_PAYLOAD_MAX_SIZE);
+    }
+
+    #disconnect(connection, reason) {
+        const sender = publicKeyToAddress(connection.remotePublicKey, this.#config)
+        console.error(`NetworkMessageRouterV1: ${reason}, sender: ${sender}`)
+        connection.end();
     }
 }
 
-export default NetworkMessageRouterV1;
+export default NetworkMessageRouterV1