trac-msb 0.2.11 → 0.2.12

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

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

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

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

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

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

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

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

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

@@ -1,99 +1,15 @@
-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'
+import { MessageHeader } from '../../../../utils/protobuf/network.cjs';
 
 class NetworkMessageRouterV1 {
-    #config
-    #livenessRequestHandler
-    #broadcastTransactionHandler
+    #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
-        );
+    constructor(config) {
+        this.#config = config;
     }
 
-    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();
+    async route(incomingMessage) {
+        MessageHeader.decode(incomingMessage);
     }
 }
 
-export default NetworkMessageRouterV1
+export default NetworkMessageRouterV1;