trac-msb 0.2.24 → 0.3.0-beta.1

package/src/core/network/protocols/consensus/v1/validators/V1EpochProofProposalRequest.js

@@ -0,0 +1,152 @@
+import V1BaseConsensusOperation from "./V1BaseConsensusOperation.js";
+import { V1ConsensusProtocolError } from "../V1ConsensusProtocolError.js";
+import { ConsensusResultCode } from "../../../../../../utils/constants.js";
+import { uint16ToBuffer } from "../../../../../../utils/buffer.js";
+import b4a from "b4a";
+import { verifyWesolowski } from '@tracsystems/trac-vdf';
+
+class V1EpochProofProposalRequest extends V1BaseConsensusOperation {
+
+    /**
+     * Creates the proof proposal request validator.
+     *
+     * @param {Config} config Application configuration used by base validation
+     * and network identity checks.
+     * @param {State} state Ledger state. It must expose `requireCurrentEpoch()`,
+     * `requireEpoch(epoch)`, `requireSignedConsensusConfig()`, and `isIndexerAddress(address)`.
+     * @throws {Error} When consensus schemas cannot be initialized from the configuration.
+     */
+    constructor(config, state) {
+        super(config, state);
+    }
+
+    /**
+     * Validates a complete incoming epoch proof proposal request.
+     *
+     * Checks the payload schema, active consensus version, network id, proposer identity,
+     * proposal signature, proposer indexer membership, next epoch number,
+     * previous epoch record hash, consensus configuration, and VDF proof.
+     *
+     * @param {object} payload Decoded proof proposal request payload.
+     * @param {object} connection Peer connection containing `remotePublicKey`.
+     * @returns {Promise<boolean>} Resolves to `true` when every check succeeds.
+     * @throws {V1ConsensusProtocolError} When any proposal validation check fails.
+     */
+    async validate(payload, connection) {
+        return await this.validateAsProtocolError(async () => {
+            this.isPayloadSchemaValid(payload);
+            this.validateProofProposalNetworkId(payload.proof_proposal);
+            this.assertAddressWithRemotePublicKey(
+                payload.proof_proposal.proposer,
+                connection.remotePublicKey
+            );
+            await this.validateProofProposalConfig(payload.proof_proposal);
+            await this.validateSignature(payload, connection.remotePublicKey, undefined, ConsensusResultCode.PROPOSAL_SIGNATURE_INVALID);
+            await this.validateAddressIsIndexer(connection.remotePublicKey);
+            this.validateLocalNodeIsIndexer();
+            const currentEpoch = await this._state.requireCurrentEpoch();
+            this.validateIncomingEpoch(payload.proof_proposal, currentEpoch);
+            await this.validatePreviousEpochRecordHash(payload.proof_proposal, currentEpoch);
+            await this.validateProofProposalVdfProof(payload.proof_proposal);
+
+            // The signed config may have changed during VDF verification.
+            await this.validateProofProposalConfig(payload.proof_proposal);
+            return true;
+        });
+    }
+
+    /**
+     * Verifies the proof proposal VDF proof against its challenge data.
+     *
+     * Uses the canonical challenge fields and signed-state VDF difficulty and
+     * discriminant size for Wesolowski proof verification.
+     *
+     * @param {object} proofProposal Decoded proof proposal.
+     * @returns {Promise<void>}
+     * @throws {V1ConsensusProtocolError} When VDF verification fails or returns false.
+     */
+    async validateProofProposalVdfProof(proofProposal) {
+        const challengeData = this.buildProofProposalChallengeData(proofProposal);
+        const difficulty = proofProposal.difficulty.readUInt32BE(0);
+        const discriminantBitSize = proofProposal.discriminant_bit_size.readUInt16BE(0);
+
+        let verified = false;
+        try {
+            verified = await verifyWesolowski(
+                challengeData,
+                difficulty,
+                proofProposal.proof,
+                discriminantBitSize
+            );
+        } catch {
+            verified = false;
+        }
+
+        if (!verified) {
+            throw new V1ConsensusProtocolError(
+                ConsensusResultCode.VDF_PROOF_INVALID,
+                'VDF proof is invalid.'
+            );
+        }
+    }
+
+    /**
+     * Validates that the proof proposal targets the configured network.
+     *
+     * @param {object} proofProposal Decoded proof proposal.
+     * @returns {void}
+     * @throws {V1ConsensusProtocolError} When `network_id` differs from the local network id.
+     */
+    validateProofProposalNetworkId(proofProposal) {
+        const expectedNetworkId = uint16ToBuffer(this._config.networkId);
+        if (!b4a.equals(proofProposal.network_id, expectedNetworkId)) {
+            throw new V1ConsensusProtocolError(
+                ConsensusResultCode.WRONG_NETWORK_ID,
+                'Invalid proof proposal network id.'
+            );
+        }
+    }
+
+    /**
+     * Validates that the proposal advances the current epoch by exactly one.
+     *
+     * @param {object} proofProposal Decoded proof proposal containing an uint64 epoch buffer.
+     * @param {bigint} currentEpoch Current epoch snapshot used by all epoch-related checks.
+     * @returns {void}
+     * @throws {V1ConsensusProtocolError} When the proposed epoch is not `currentEpoch + 1`.
+     */
+    validateIncomingEpoch(proofProposal, currentEpoch) {
+        const proofProposalEpoch = proofProposal.epoch.readBigUInt64BE(0);
+        if (proofProposalEpoch !== currentEpoch + 1n) {
+            throw new V1ConsensusProtocolError(
+                ConsensusResultCode.EPOCH_INVALID,
+                `Unexpected epoch. Proof proposal must be ${currentEpoch + 1n} but got ${proofProposalEpoch}`
+            );
+        }
+    }
+
+    /**
+     * Validates that the proposal references the current epoch record hash.
+     *
+     * Reads the current epoch id and its stored hash, then compares that hash
+     * with `previous_epoch_record_hash` from the proposal.
+     *
+     * @param {object} proofProposal Decoded proof proposal.
+     * @param {bigint} currentEpoch Current epoch snapshot used by all epoch-related checks.
+     * @returns {Promise<void>}
+     * @throws {V1ConsensusProtocolError} When the previous epoch record hash does not match state.
+     */
+    async validatePreviousEpochRecordHash(proofProposal, currentEpoch) {
+        const currentEpochHash = await this._state.requireEpoch(currentEpoch);
+        const epochHashInProofProposal = proofProposal.previous_epoch_record_hash;
+        if (!b4a.equals(currentEpochHash, epochHashInProofProposal)) {
+            throw new V1ConsensusProtocolError(
+                ConsensusResultCode.PREVIOUS_EPOCH_RECORD_HASH_INVALID,
+                `Previous epoch record hash mismatch for epoch ${currentEpoch}: expected ${currentEpochHash.toString('hex')}, got ${epochHashInProofProposal.toString('hex')}`
+            );
+        }
+
+    }
+}
+
+export default V1EpochProofProposalRequest;

package/src/core/network/protocols/consensus/v1/validators/consensusValidationSchemaHelpers.js

@@ -0,0 +1,145 @@
+import b4a from 'b4a';
+import {
+    ConsensusResultCode,
+    EPOCH_APPENDER_SELECTION_COUNTER_LIMIT,
+    EPOCH_BYTE_LENGTH,
+    VDF_DISCRIMINANT_SIZE,
+    VDF_PROOF_BYTE_LENGTHS,
+} from '../../../../../../utils/constants.js';
+
+/**
+ * Checks that the proof length matches the discriminant size in the proposal.
+ *
+ * @param {object} proofProposal Proposal checked by the compiled schema.
+ * @param {object[]} errors Validation errors collected by the schema.
+ * @returns {object} Original proposal.
+ */
+export function validateProofProposalLength(proofProposal, errors) {
+    const discriminant = proofProposal?.discriminant_bit_size;
+    const proof = proofProposal?.proof;
+    if (!b4a.isBuffer(discriminant) || discriminant.length !== VDF_DISCRIMINANT_SIZE) {
+        return proofProposal;
+    }
+
+    const discriminantBitSize = discriminant.readUInt16BE(0);
+    const expectedProofLength = VDF_PROOF_BYTE_LENGTHS[discriminantBitSize];
+    if (!Number.isInteger(expectedProofLength)) {
+        errors.push({
+            type: 'unsupportedDiscriminantBitSize',
+            field: 'proof_proposal.discriminant_bit_size',
+            actual: discriminantBitSize,
+            expected: Object.keys(VDF_PROOF_BYTE_LENGTHS).map(Number),
+            message: 'Discriminant bit size must be one of: 1024, 2048, 4096.'
+        });
+        return proofProposal;
+    }
+
+    if (b4a.isBuffer(proof) && proof.length !== expectedProofLength) {
+        errors.push({
+            type: 'bufferLength',
+            field: 'proof_proposal.proof',
+            actual: proof.length,
+            expected: expectedProofLength,
+            message: `Proof must be a Buffer with length ${expectedProofLength}.`
+        });
+    }
+    return proofProposal;
+}
+
+/**
+ * Requires an approval for OK responses and forbids it for other results.
+ *
+ * @param {object} response Response checked by the compiled schema.
+ * @param {object[]} errors Validation errors collected by the schema.
+ * @returns {object} Original response.
+ */
+export function validateProofProposalApprovalPresence(response, errors) {
+    if (!response || typeof response !== 'object') {
+        return response;
+    }
+    const requiresApproval = response.result === ConsensusResultCode.OK;
+    const hasApproval = response.approval !== undefined && response.approval !== null;
+    if (requiresApproval !== hasApproval) {
+        errors.push({
+            type: 'conditionalDependency',
+            field: 'proof_proposal_response.approval',
+            message: requiresApproval
+                ? 'Approval is required when the result is OK.'
+                : 'Approval is only allowed when the result is OK.'
+        });
+    }
+    return response;
+}
+
+/**
+ * Checks the allowed counter range after the buffer rule checks its shape.
+ *
+ * @param {Buffer} counter Encoded election counter.
+ * @param {object[]} errors Validation errors collected by the schema.
+ * @returns {Buffer} Original counter.
+ */
+export function validateSelectionCounter(counter, errors) {
+    if (!b4a.isBuffer(counter) || counter.length !== EPOCH_BYTE_LENGTH) {
+        return counter;
+    }
+    const counterValue = counter.readBigUInt64BE(0);
+    if (counterValue === 0n || counterValue > EPOCH_APPENDER_SELECTION_COUNTER_LIMIT) {
+        errors.push({
+            type: 'selectionCounter',
+            actual: counterValue.toString(),
+            message: 'Selection counter is outside the allowed range.'
+        });
+    }
+    return counter;
+}
+
+/**
+ * Builds the buffer check during schema compilation. The validator provides this.makeError.
+ *
+ * @this {import('fastest-validator').default}
+ * @param {object} rule Buffer field definition and error messages.
+ * @returns {{source: string}} Code used by the compiled validator.
+ */
+export function compileBufferRule({ schema, messages }) {
+    const isBuffer = b4a.isBuffer;
+    const allowEmpty = schema.allowEmpty === true;
+    const exactLength = Number.isInteger(schema.length) ? schema.length : null;
+    const minLength = Number.isInteger(schema.min) ? schema.min : null;
+    const maxLength = Number.isInteger(schema.max) ? schema.max : null;
+    return {
+        source: `
+            if (!${isBuffer}(value)) {
+                ${this.makeError({ type: "buffer", actual: "value", messages })}
+                return value;
+            }
+            const len = value.length;
+            ${exactLength === null ? '' : `
+            if (len !== ${exactLength}) {
+                ${this.makeError({ type: "bufferLength", expected: exactLength, actual: "len", messages })}
+            }`}
+            ${minLength === null ? '' : `
+            if (len < ${minLength}) {
+                ${this.makeError({ type: "bufferMinLength", expected: minLength, actual: "len", messages })}
+            }`}
+            ${maxLength === null ? '' : `
+            if (len > ${maxLength}) {
+                ${this.makeError({ type: "bufferMaxLength", expected: maxLength, actual: "len", messages })}
+            }`}
+            if (len === 0 && !${allowEmpty}) {
+                ${this.makeError({ type: "emptyBuffer", actual: "len", messages })}
+                return value;
+            }
+            let isZeroFilled = true;
+            for (let i = 0; i < len; i++) {
+                if (value[i] !== 0) {
+                    isZeroFilled = false;
+                    break;
+                }
+            }
+            if (isZeroFilled) {
+                ${this.makeError({ type: "nonZeroBuffer", actual: "value", messages })}
+            }
+            return value;
+        `,
+    };
+}

package/src/core/network/protocols/shared/ConnectionOperationHandler.js

@@ -0,0 +1,27 @@
+import {publicKeyToAddress} from "../../../../utils/helpers.js";
+
+export default class ConnectionOperationHandler {
+    #config;
+
+    constructor(config) {
+        this.#config = config;
+    }
+
+    get config() {
+        return this.#config;
+    }
+
+    async sendResponseAndMaybeClose(protocolSession, connection, response, endConnection = true) {
+        protocolSession.sendAndForget(response);
+        if (!endConnection) return;
+
+        await connection.flush();
+        connection.end();
+    }
+
+    displayError(step = "undefined step", senderPublicKey, error) {
+        const errorMessage = error?.message ?? 'Unexpected error';
+        console.error(`${this.constructor.name}: ${step} ${publicKeyToAddress(senderPublicKey, this.#config)}: ${errorMessage}`);
+    }
+
+}

package/src/core/network/protocols/{NetworkMessages.js → validators/ValidatorMessages.js}

@@ -1,10 +1,10 @@
-import NetworkMessageRouter from './legacy/NetworkMessageRouter.js';
-import NetworkMessageRouterV1 from './v1/NetworkMessageRouter.js';
-import ProtocolSession from './ProtocolSession.js';
-import LegacyProtocol from './LegacyProtocol.js';
-import V1Protocol from './V1Protocol.js';
+import ValidatorLegacyMessageRouter from './legacy/ValidatorLegacyMessageRouter.js';
+import ValidatorV1MessageRouter from './v1/ValidatorV1MessageRouter.js';
+import ValidatorProtocolSession from './ValidatorProtocolSession.js';
+import ValidatorLegacyProtocol from './legacy/ValidatorLegacyProtocol.js';
+import ValidatorV1Protocol from './v1/ValidatorV1Protocol.js';
 
-class NetworkMessages {
+class ValidatorMessages {
     #legacyMessageRouter;
     #v1MessageRouter;
     #config;
@@ -23,7 +23,7 @@ class NetworkMessages {
         this.#config = config;
         this.#wallet = wallet;
         this.#pendingRequestsService = pendingRequestsService;
-        this.#legacyMessageRouter = new NetworkMessageRouter(
+        this.#legacyMessageRouter = new ValidatorLegacyMessageRouter(
             state,
             wallet,
             rateLimiterService,
@@ -31,7 +31,7 @@ class NetworkMessages {
             this.#config
         );
 
-        this.#v1MessageRouter = new NetworkMessageRouterV1(
+        this.#v1MessageRouter = new ValidatorV1MessageRouter(
             state,
             wallet,
             rateLimiterService,
@@ -42,28 +42,38 @@ class NetworkMessages {
         );
     }
 
-    async setupProtomuxMessages(connection) {
+    createProtocolSession(connection) {
         // Attach a Protomux instance to this Hyperswarm connection.
         // Protomux multiplexes multiple logical protocol channels over a single encrypted stream.
 
-        const legacyProtocol = new LegacyProtocol(
+        const legacyProtocol = new ValidatorLegacyProtocol(
             this.#legacyMessageRouter,
             connection,
             null,
             this.#config
         );
 
-        const v1Protocol = new V1Protocol(
+        const v1Protocol = new ValidatorV1Protocol(
             this.#v1MessageRouter,
             connection,
             this.#pendingRequestsService,
             this.#config
         );
 
-        // ProtocolSession is attached to the Hyperswarm connection so other parts of the system (e.g. tryConnect)
+        // ValidatorProtocolSession is attached to the Hyperswarm connection so other parts of the system (e.g. tryConnect)
         // can send messages without knowing how Protomux was initialized.
-        connection.protocolSession = new ProtocolSession(legacyProtocol, v1Protocol, this.#wallet, this.#config);
+        return new ValidatorProtocolSession(legacyProtocol, v1Protocol, this.#wallet, this.#config);
+    }
+
+    attachChannel(connection) {
+        connection.protocolSessions ??= {};
+        if (connection.protocolSessions.validator) return;
+        connection.protocolSessions.validator = this.createProtocolSession(connection);
+    }
+
+    prepareConnection(connection) {
+        this.attachChannel(connection);
     }
 }
 
-export default NetworkMessages;
+export default ValidatorMessages;

package/src/core/network/protocols/{ProtocolSession.js → validators/ValidatorProtocolSession.js}

@@ -1,15 +1,15 @@
-// ProtocolSession is a per-peer (per Hyperswarm connection) bridge that exposes the available
+// ValidatorProtocolSession 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';
+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 {
+class ValidatorProtocolSession {
     #legacyProtocol;
     #v1Protocol;
     #preferredProtocol = null;
@@ -51,24 +51,24 @@ class ProtocolSession {
     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}`);
+            //this.#logger.warn(`ValidatorProtocolSession: 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');
+        this.#logger.debug('ValidatorProtocolSession: set preferred protocol to LEGACY');
     }
 
     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}`);
+            //this.#logger.warn(`ValidatorProtocolSession: 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');
+        this.#logger.debug('ValidatorProtocolSession: set preferred protocol to V1');
     }
 
     /**
@@ -83,25 +83,25 @@ class ProtocolSession {
     */
     async probe() {
         if (this.isProbed()) {
-            this.#logger.warn(`ProtocolSession: preferred protocol is already set. Skipping probe. Current preferred protocol: ${this.#preferredProtocol}`);
+            this.#logger.warn(`ValidatorProtocolSession: 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');
+                throw new Error('ValidatorProtocolSession: 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.#logger.warn(`ValidatorProtocolSession: 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.#logger.debug(`ValidatorProtocolSession: v1 protocol probe failed, falling back to legacy. Details: ${err?.message ?? err}`);
             this.setLegacyAsPreferredProtocol();
         }
     }
@@ -119,14 +119,14 @@ class ProtocolSession {
                     return await this.#v1Protocol.send(message);
                 }
                 catch (err) {
-                    this.#logger.error(`ProtocolSession: v1 health check failed: ${err?.message ?? err}`);
+                    this.#logger.error(`ValidatorProtocolSession: 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');
+                this.#logger.warn('ValidatorProtocolSession: 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.');
+                this.#logger.warn('ValidatorProtocolSession: preferred protocol not set. Call probe() first.');
                 return ResultCode.UNSPECIFIED; // TODO: Define a more specific result code.
         }
     }
@@ -136,10 +136,7 @@ class ProtocolSession {
      * @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;
+        return this.isProbed() && this.#preferredProtocol === this.#supportedProtocols.V1;
     }
 
     // TODO: Consider moving this method to be used only in V1 internally, just like 'encode'
@@ -160,7 +157,7 @@ class ProtocolSession {
             try {
                 this.#legacyProtocol.close();
             } catch (e) {
-                this.#logger.error(`ProtocolSession: failed to close legacy channel: ${e?.message ?? e}`); // TODO: Think about throwing instead
+                this.#logger.error(`ValidatorProtocolSession: failed to close legacy channel: ${e?.message ?? e}`); // TODO: Think about throwing instead
             }
         }
 
@@ -168,14 +165,14 @@ class ProtocolSession {
             try {
                 this.#v1Protocol.close();
             } catch (e) {
-                this.#logger.error(`ProtocolSession: failed to close v1 channel: ${e?.message ?? e}`); // TODO: Think about throwing instead
+                this.#logger.error(`ValidatorProtocolSession: 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');
+            throw new Error('ValidatorProtocolSession: wallet/config not set for liveness request');
         }
         const requestId = generateUUID();
         return await networkMessageFactory(this.#wallet, this.#config)
@@ -183,4 +180,4 @@ class ProtocolSession {
     }
 }
 
-export default ProtocolSession;
+export default ValidatorProtocolSession;

package/src/core/network/protocols/{legacy/NetworkMessageRouter.js → validators/legacy/ValidatorLegacyMessageRouter.js}

@@ -5,10 +5,10 @@ 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 { NETWORK_MESSAGE_TYPES } from '../../../../../utils/constants.js';
+import * as operation from '../../../../../utils/applyOperations.js';
 
-class NetworkMessageRouter {
+class ValidatorLegacyMessageRouter {
     #handlers;
     #config;
 
@@ -37,9 +37,9 @@ class NetworkMessageRouter {
         const channelString = b4a.toString(this.#config.channel, 'utf8');
 
         // We received a legacy message, so we set the connection protocol accordingly
-        connection.protocolSession.setLegacyAsPreferredProtocol();
+        connection.protocolSessions.validator.setLegacyAsPreferredProtocol();
         if (this.#isGetRequest(incomingMessage)) {
-            await this.#handlers.get.handle(incomingMessage, connection, channelString);
+            await this.#handlers.get.handle(incomingMessage, connection, connection.protocolSessions.validator, channelString);
         }
         else if (this.#isResponse(incomingMessage)) {
             await this.#handlers.response.handle(incomingMessage, channelString);
@@ -87,4 +87,4 @@ class NetworkMessageRouter {
 }
 
 
-export default NetworkMessageRouter;
+export default ValidatorLegacyMessageRouter;

package/src/core/network/protocols/{LegacyProtocol.js → validators/legacy/ValidatorLegacyProtocol.js}

@@ -1,9 +1,9 @@
 import Protomux from 'protomux';
-import ProtocolInterface from './ProtocolInterface.js';
+import ValidatorProtocolInterface from '../shared/ValidatorProtocolInterface.js';
 import b4a from 'b4a';
 import c from 'compact-encoding';
 
-class LegacyProtocol extends ProtocolInterface {
+class ValidatorLegacyProtocol extends ValidatorProtocolInterface {
     #channel;
     #session;
     #config;
@@ -35,6 +35,8 @@ class LegacyProtocol extends ProtocolInterface {
             onclose() { }
         });
 
+        if (!this.#channel) return; // connection already destroyed before protocol setup completed
+
         this.#channel.open();
 
         // Todo: Abstract in a separate function
@@ -42,7 +44,7 @@ class LegacyProtocol extends ProtocolInterface {
             encoding: c.json,
             onmessage: async (incomingMessage) => {
                 this.#router.route(incomingMessage, connection).catch((err) => {
-                    console.error(`LegacyProtocol: unhandled router error: ${err.message}`);
+                    console.error(`ValidatorLegacyProtocol: unhandled router error: ${err.message}`);
                     try {
                         connection.end();
                     } catch {
@@ -61,17 +63,17 @@ class LegacyProtocol extends ProtocolInterface {
     async send(message) {
         this.sendAndForget(message);
         // TODO: Change 'null' to an appropriate response if needed in the future
-        return Promise.resolve(null); // This is to maintain consistency with the ProtocolInterface and v1 protocol.
+        return Promise.resolve(null); // This is to maintain consistency with the ValidatorProtocolInterface and v1 protocol.
     }
 
     sendAndForget(message) {
-        this.#session.send(message);
+        this.#session?.send(message);
     }
 
     close() {
-        this.#channel.close();
+        this.#channel?.close();
     }
 
 }
 
-export default LegacyProtocol;
+export default ValidatorLegacyProtocol;

package/src/core/network/protocols/{legacy → validators/legacy}/handlers/BaseStateOperationHandler.js

@@ -1,5 +1,5 @@
 import b4a from 'b4a';
-import {publicKeyToAddress} from "../../../../../utils/helpers.js";
+import {publicKeyToAddress} from "../../../../../../utils/helpers.js";
 
 class BaseStateOperationHandler {
     #state;