trac-msb 0.2.13 → 0.2.15

package/src/core/network/protocols/v1/handlers/V1BroadcastTransactionOperationHandler.js

@@ -1,389 +0,0 @@
-import {networkMessageFactory} from "../../../../../messages/network/v1/networkMessageFactory.js";
-import {
-    NETWORK_CAPABILITIES,
-    OperationType,
-    ResultCode
-} from "../../../../../utils/constants.js";
-import {
-    getResultCode,
-    V1TxInvalidPayloadError,
-    V1NodeHasNoWriteAccess,
-    shouldEndConnection,
-    V1TxAcceptedProofUnavailable,
-    V1UnexpectedError,
-    V1NodeOverloadedError,
-    V1TxAlreadyPendingError,
-    V1TimeoutError,
-    V1ProtocolError
-} from "../V1ProtocolError.js";
-import V1BroadcastTransactionRequest from "../validators/V1BroadcastTransactionRequest.js";
-import {
-    unsafeDecodeApplyOperation,
-    unsafeEncodeApplyOperation
-} from "../../../../../utils/protobuf/operationHelpers.js";
-import {isBootstrapDeployment, isRoleAccess, isTransaction, isTransfer} from '../../../../../utils/applyOperations.js';
-import PartialRoleAccessValidator from "../../shared/validators/PartialRoleAccessValidator.js";
-import PartialBootstrapDeploymentValidator from "../../shared/validators/PartialBootstrapDeploymentValidator.js";
-import PartialTransactionValidator from "../../shared/validators/PartialTransactionValidator.js";
-import PartialTransferValidator from "../../shared/validators/PartialTransferValidator.js";
-import {applyStateMessageFactory} from "../../../../../messages/state/applyStateMessageFactory.js";
-import V1BroadcastTransactionResponse from "../validators/V1BroadcastTransactionResponse.js";
-import V1BaseOperationHandler from "./V1BaseOperationHandler.js";
-import {
-    TransactionPoolMissingCommitReceiptError,
-    TransactionPoolProofUnavailableError,
-    TransactionPoolFullError, TransactionPoolInvalidIncomingDataError, TransactionPoolAlreadyQueuedError
-} from "../../../services/TransactionPoolService.js";
-import {
-    PendingCommitInvalidTxHashError,
-    PendingCommitAlreadyExistsError,
-    PendingCommitBufferFullError, PendingCommitTimeoutError
-} from "../../../services/TransactionCommitService.js";
-import b4a from "b4a";
-
-class V1BroadcastTransactionOperationHandler extends V1BaseOperationHandler {
-    #state;
-    #wallet;
-    #txPoolService;
-    #broadcastTransactionRequestValidator;
-    #broadcastTransactionResponseValidator;
-    #partialRoleAccessValidator;
-    #partialBootstrapDeploymentValidator;
-    #partialTransactionValidator;
-    #partialTransferValidator;
-    #transactionCommitService;
-
-    constructor(state, wallet, rateLimiterService, txPoolService, pendingRequestService, transactionCommitService, config) {
-        super(rateLimiterService, pendingRequestService, config);
-        this.#state = state;
-        this.#wallet = wallet;
-        this.#txPoolService = txPoolService;
-        this.#broadcastTransactionRequestValidator = new V1BroadcastTransactionRequest(config);
-        this.#partialRoleAccessValidator = new PartialRoleAccessValidator(state, this.#wallet.address, config);
-        this.#partialBootstrapDeploymentValidator = new PartialBootstrapDeploymentValidator(state, this.#wallet.address, config);
-        this.#partialTransactionValidator = new PartialTransactionValidator(state, this.#wallet.address, config);
-        this.#partialTransferValidator = new PartialTransferValidator(state, this.#wallet.address, config);
-        this.#broadcastTransactionResponseValidator = new V1BroadcastTransactionResponse(state, config);
-        this.#transactionCommitService = transactionCommitService;
-    }
-
-    async handleRequest(message, connection) {
-        let resultCode = ResultCode.OK;
-        let endConnection = false;
-        let proof = null
-        let timestamp = 0;
-
-        try {
-            this.applyRateLimit(connection);
-            await this.#broadcastTransactionRequestValidator.validate(message, connection.remotePublicKey);
-            await this.#validationCapability();
-            this.#isTxPoolFull();
-            const decodedTransaction = this.decodeApplyOperation(message.broadcast_transaction_request.data);
-            this.#sanitizeDecodedPartialTransaction(decodedTransaction);
-            const receipt = await this.dispatchTransaction(decodedTransaction);
-            proof = receipt.proof;
-            timestamp = receipt.timestamp;
-        } catch (error) {
-            const protocolError = error instanceof V1ProtocolError
-                ? error
-                : new V1UnexpectedError(error?.message ?? 'Unexpected error', true);
-            resultCode = getResultCode(protocolError);
-            if (
-                resultCode === ResultCode.TX_ACCEPTED_PROOF_UNAVAILABLE &&
-                Number.isSafeInteger(protocolError.timestamp) &&
-                protocolError.timestamp > 0
-            ) {
-                timestamp = protocolError.timestamp;
-            }
-            endConnection = shouldEndConnection(protocolError);
-            this.displayError(
-                "failed to process broadcast transaction request from sender",
-                connection.remotePublicKey,
-                protocolError
-            );
-        }
-
-        try {
-            const response = await this.#buildBroadcastTransactionResponse(
-                message.id,
-                NETWORK_CAPABILITIES,
-                proof,
-                timestamp,
-                resultCode,
-            );
-
-            await this.sendResponseAndMaybeClose(
-                connection,
-                response,
-                endConnection
-            );
-        } catch (error) {
-            this.displayError(
-                "failed to build/send response to sender",
-                connection.remotePublicKey,
-                error
-            );
-            connection.end();
-        }
-    }
-
-    async handleResponse(message, connection) {
-        try {
-            this.applyRateLimit(connection);
-            await this.resolvePendingResponse(
-                message,
-                connection,
-                this.#broadcastTransactionResponseValidator,
-                this.#extractBroadcastResultCode,
-            );
-        } catch (error) {
-            this.handlePendingResponseError(
-                message.id,
-                connection,
-                error,
-                "failed to process broadcast transaction response from sender"
-            );
-        }
-    }
-
-    async #buildBroadcastTransactionResponse(id, capabilities, proof, timestamp = null, resultCode) {
-        try {
-            return await networkMessageFactory(this.#wallet, this.config).buildBroadcastTransactionResponse(
-                id,
-                capabilities,
-                resultCode,
-                proof,
-                timestamp
-            );
-        } catch (error) {
-            throw new V1UnexpectedError(`Failed to build broadcast transaction response: ${error.message}`);
-        }
-    }
-
-    decodeApplyOperation(message) {
-        try {
-            return unsafeDecodeApplyOperation(message);
-        } catch (error) {
-            throw new V1UnexpectedError(`Failed to decode apply operation from message: ${error.message}`);
-        }
-    }
-
-    #sanitizeDecodedPartialTransaction(decodedTransaction) {
-        // Protobuf decode sets optional completion fields as null, but partial validators expect those fields to be absent.
-        // Otherwise, the presence of null fields causes validation to fail with "Expected type X but got null" errors.
-
-        const type = decodedTransaction?.type;
-        const operationKey = this.#getOperationPayloadKey(type);
-
-        if (!operationKey || !decodedTransaction?.[operationKey] || typeof decodedTransaction[operationKey] !== 'object') {
-            return;
-        }
-
-        for (const completionField of ['va', 'vn', 'vs']) {
-            if (decodedTransaction[operationKey][completionField] === null) {
-                delete decodedTransaction[operationKey][completionField];
-            }
-        }
-    }
-
-    #getOperationPayloadKey(type) {
-        if (isRoleAccess(type)) return 'rao';
-        if (isTransaction(type)) return 'txo';
-        if (isBootstrapDeployment(type)) return 'bdo';
-        if (isTransfer(type)) return 'tro';
-        return null;
-    }
-
-    #isTxPoolFull() {
-        try {
-            this.#txPoolService.validateEnqueue();
-        } catch (error) {
-            if (error instanceof TransactionPoolFullError) {
-                throw new V1NodeOverloadedError('Transaction pool is full, ignoring incoming transaction.');
-            }
-            throw error;
-        }
-    }
-
-    async #validationCapability() {
-        const isAllowedToValidate = await this.#state.allowedToValidate(this.#wallet.address);
-        const isAdminAllowedToValidate = await this.#state.isAdminAllowedToValidate();
-        const canValidate = isAllowedToValidate || isAdminAllowedToValidate;
-        if (!canValidate) {
-            throw new V1NodeHasNoWriteAccess('State is not writable or is an indexer without admin privileges.');
-        }
-    }
-
-    async dispatchTransaction(decodedTransaction) {
-        if (!decodedTransaction || !Number.isInteger(decodedTransaction.type) || decodedTransaction.type === 0) {
-            throw new V1TxInvalidPayloadError('Decoded transaction type is missing.', false);
-        }
-        if (!this.#transactionCommitService) {
-            throw new V1UnexpectedError('TransactionCommitService is not configured.');
-        }
-
-        const type = decodedTransaction.type;
-        let completeTransactionOperation;
-
-        // TODO: Consider moving logic below to strategy design pattern.
-        if (isRoleAccess(type)) {
-            await this.#partialRoleAccessValidator.validate(decodedTransaction);
-            completeTransactionOperation = await this.#buildCompleteRoleAccessOperation(decodedTransaction);
-        } else if (isTransaction(type)) {
-            await this.#partialTransactionValidator.validate(decodedTransaction);
-            completeTransactionOperation = await this.#buildCompleteTransactionOperation(decodedTransaction);
-        } else if (isBootstrapDeployment(type)) {
-            await this.#partialBootstrapDeploymentValidator.validate(decodedTransaction);
-            completeTransactionOperation = await this.#buildCompleteBootstrapDeploymentOperation(decodedTransaction);
-        } else if (isTransfer(type)) {
-            await this.#partialTransferValidator.validate(decodedTransaction);
-            completeTransactionOperation = await this.#buildCompleteTransferOperation(decodedTransaction);
-        } else {
-            throw new V1TxInvalidPayloadError(`Unsupported transaction type: ${type}`, false);
-        }
-
-        const payloadKey = this.#getOperationPayloadKey(type);
-        const txHash = b4a.toString(decodedTransaction[payloadKey].tx, 'hex');
-
-        const encodedCompleteTransaction = unsafeEncodeApplyOperation(completeTransactionOperation);
-        let pendingCommit;
-
-        try {
-            pendingCommit = this.#transactionCommitService.registerPendingCommit(txHash);
-            pendingCommit.catch(() => {});
-        } catch (error) {
-            if (error instanceof PendingCommitInvalidTxHashError) {
-                throw new V1ProtocolError(ResultCode.TX_HASH_INVALID_FORMAT, error.message, false);
-            }
-            if (error instanceof PendingCommitAlreadyExistsError) {
-                throw new V1TxAlreadyPendingError(error.message);
-            }
-            if (error instanceof PendingCommitBufferFullError) {
-                throw new V1NodeOverloadedError(error.message);
-            }
-            throw error;
-        }
-
-        try {
-            this.#txPoolService.addTransaction(txHash, encodedCompleteTransaction);
-        } catch (error) {
-            let err = error;
-            if (error instanceof TransactionPoolFullError) {
-                err = new V1NodeOverloadedError(error.message);
-            } else if (error instanceof TransactionPoolAlreadyQueuedError) {
-                err = new V1TxAlreadyPendingError(error.message);
-            } else if (error instanceof TransactionPoolInvalidIncomingDataError) {
-                err = new V1ProtocolError(
-                    ResultCode.INTERNAL_ENQUEUE_VALIDATION_FAILED,
-                    `Internal enqueue validation failed: ${error.message}`,
-                    false
-                );
-            }
-            this.#transactionCommitService.rejectPendingCommit(txHash, err);
-            throw err; // will be mapped anyway on lower level.
-        }
-
-        let receipt;
-        try {
-            receipt = await pendingCommit;
-        } catch (error) {
-            if (error instanceof TransactionPoolProofUnavailableError) {
-                throw new V1TxAcceptedProofUnavailable(error.message, false, error.timestamp);
-            }
-            if (error instanceof TransactionPoolMissingCommitReceiptError) {
-                throw new V1ProtocolError(ResultCode.TX_COMMITTED_RECEIPT_MISSING, error.message, false);
-            }
-            if (error instanceof PendingCommitTimeoutError) {
-                throw new V1TimeoutError(error.message);
-            }
-            throw error;
-        }
-
-        return receipt;
-    }
-
-
-    //TODO: Move responsibility to new class (next 4 functions)
-    async #buildCompleteRoleAccessOperation(decodedTransaction) {
-        const factory = applyStateMessageFactory(this.#wallet, this.config);
-
-        switch (decodedTransaction.type) {
-            case OperationType.ADD_WRITER:
-                return factory.buildCompleteAddWriterMessage(
-                    decodedTransaction.address,
-                    decodedTransaction.rao.tx,
-                    decodedTransaction.rao.txv,
-                    decodedTransaction.rao.iw,
-                    decodedTransaction.rao.in,
-                    decodedTransaction.rao.is
-                );
-            case OperationType.REMOVE_WRITER:
-                return factory.buildCompleteRemoveWriterMessage(
-                    decodedTransaction.address,
-                    decodedTransaction.rao.tx,
-                    decodedTransaction.rao.txv,
-                    decodedTransaction.rao.iw,
-                    decodedTransaction.rao.in,
-                    decodedTransaction.rao.is
-                );
-            case OperationType.ADMIN_RECOVERY:
-                return factory.buildCompleteAdminRecoveryMessage(
-                    decodedTransaction.address,
-                    decodedTransaction.rao.tx,
-                    decodedTransaction.rao.txv,
-                    decodedTransaction.rao.iw,
-                    decodedTransaction.rao.in,
-                    decodedTransaction.rao.is
-                );
-            default:
-                throw new V1TxInvalidPayloadError(`Unsupported role access transaction type: ${decodedTransaction.type}`, false);
-        }
-    }
-
-    async #buildCompleteTransactionOperation(decodedTransaction) {
-        return applyStateMessageFactory(this.#wallet, this.config)
-            .buildCompleteTransactionOperationMessage(
-                decodedTransaction.address,
-                decodedTransaction.txo.tx,
-                decodedTransaction.txo.txv,
-                decodedTransaction.txo.iw,
-                decodedTransaction.txo.in,
-                decodedTransaction.txo.ch,
-                decodedTransaction.txo.is,
-                decodedTransaction.txo.bs,
-                decodedTransaction.txo.mbs
-            );
-    }
-
-    async #buildCompleteBootstrapDeploymentOperation(decodedTransaction) {
-        return applyStateMessageFactory(this.#wallet, this.config)
-            .buildCompleteBootstrapDeploymentMessage(
-                decodedTransaction.address,
-                decodedTransaction.bdo.tx,
-                decodedTransaction.bdo.txv,
-                decodedTransaction.bdo.bs,
-                decodedTransaction.bdo.ic,
-                decodedTransaction.bdo.in,
-                decodedTransaction.bdo.is
-            );
-    }
-
-    async #buildCompleteTransferOperation(decodedTransaction) {
-        return applyStateMessageFactory(this.#wallet, this.config)
-            .buildCompleteTransferOperationMessage(
-                decodedTransaction.address,
-                decodedTransaction.tro.tx,
-                decodedTransaction.tro.txv,
-                decodedTransaction.tro.in,
-                decodedTransaction.tro.to,
-                decodedTransaction.tro.am,
-                decodedTransaction.tro.is
-            );
-    }
-
-    #extractBroadcastResultCode(payload) {
-        return payload.broadcast_transaction_response.result;
-    }
-}
-
-export default V1BroadcastTransactionOperationHandler;

package/src/core/network/protocols/v1/handlers/V1LivenessOperationHandler.js

@@ -1,87 +0,0 @@
-import { networkMessageFactory } from "../../../../../messages/network/v1/networkMessageFactory.js";
-import { NETWORK_CAPABILITIES, ResultCode } from "../../../../../utils/constants.js";
-import V1LivenessRequest from "../validators/V1LivenessRequest.js";
-import {getResultCode, shouldEndConnection, V1UnexpectedError} from "../V1ProtocolError.js";
-import V1LivenessResponse from "../validators/V1LivenessResponse.js";
-import V1BaseOperationHandler from "./V1BaseOperationHandler.js";
-
-class V1LivenessOperationHandler extends V1BaseOperationHandler {
-    #wallet;
-    #v1LivenessRequestValidator;
-    #v1LivenessResponseValidator;
-
-    constructor(wallet, rateLimiterService, pendingRequestService, config) {
-        super(rateLimiterService, pendingRequestService, config);
-        this.#wallet = wallet;
-        this.#v1LivenessRequestValidator = new V1LivenessRequest(config);
-        this.#v1LivenessResponseValidator = new V1LivenessResponse(config);
-    }
-
-    async handleRequest(message, connection) {
-        let resultCode = ResultCode.OK;
-        let endConnection = false;
-        try {
-            this.applyRateLimit(connection);
-            await this.#v1LivenessRequestValidator.validate(message, connection.remotePublicKey);
-        } catch (error) {
-            resultCode = getResultCode(error);
-            endConnection = shouldEndConnection(error);
-            this.displayError("failed to process liveness request from sender",
-                connection.remotePublicKey,
-                error
-            );
-        }
-
-        try {
-            const response = await this.#buildLivenessResponsePayload(message.id, NETWORK_CAPABILITIES, resultCode);
-            await this.sendResponseAndMaybeClose(
-                connection,
-                response,
-                endConnection
-            );
-        } catch (error) {
-            this.displayError("failed to build/send response to sender",
-                connection.remotePublicKey,
-                error
-            );
-            connection.end();
-        }
-    }
-
-    async handleResponse(message, connection) {
-        try {
-            this.applyRateLimit(connection);
-            await this.resolvePendingResponse(
-                message,
-                connection,
-                this.#v1LivenessResponseValidator,
-                this.#extractLivenessResultCode
-            );
-        } catch (error) {
-            this.handlePendingResponseError(
-                message.id,
-                connection,
-                error,
-                "Failed to process liveness response from sender"
-            );
-        }
-    }
-
-    async #buildLivenessResponsePayload(id, capabilities, resultCode) {
-        try {
-            return await networkMessageFactory(this.#wallet, this.config).buildLivenessResponse(
-                id,
-                capabilities,
-                resultCode
-            );
-        } catch (error) {
-            throw new V1UnexpectedError(`Failed to build liveness response: ${error.message}`);
-        }
-    }
-
-    #extractLivenessResultCode(payload) {
-        return payload.liveness_response.result;
-    }
-}
-
-export default V1LivenessOperationHandler;

package/src/core/network/protocols/v1/validators/V1BaseOperation.js

@@ -1,211 +0,0 @@
-import V1ValidationSchema from "./V1ValidationSchema.js";
-import {NetworkOperationType, ResultCode} from "../../../../../utils/constants.js";
-import PeerWallet from "trac-wallet";
-import b4a from "b4a";
-import {
-    createMessage,
-    encodeCapabilities,
-    idToBuffer,
-    safeWriteUInt32BE,
-    timestampToBuffer
-} from "../../../../../utils/buffer.js";
-import {
-    V1InvalidPayloadError,
-    V1ProtocolError,
-    V1SignatureInvalidError,
-    V1UnexpectedError,
-} from "../V1ProtocolError.js";
-import _ from 'lodash';
-class V1BaseOperation {
-    #v1ValidationSchema
-    #config
-
-    constructor(config) {
-        this.#config = config;
-        this.#v1ValidationSchema = new V1ValidationSchema();
-    }
-
-    async validate(payload, connection, pendingRequestServiceEntry) {
-        throw new Error("Method 'validate()' must be implemented.");
-    }
-
-    isPayloadSchemaValid(payload) {
-        if (_.isNil(payload?.type)) {
-            throw new V1InvalidPayloadError('Payload or payload type is missing.');
-        }
-
-        const selectedValidator = this.#selectCheckSchemaValidator(payload.type);
-        const isPayloadValid = selectedValidator(payload);
-        if (!isPayloadValid) {
-            throw new V1InvalidPayloadError('Payload is invalid.');
-        }
-    }
-
-    async validateSignature(payload, remotePublicKey) {
-        let signature;
-        let message;
-        try {
-            const result = this.#buildSignatureMessage(payload);
-            signature = result.signature;
-            message = result.message;
-        } catch (error) {
-            if (error instanceof V1ProtocolError) {
-                throw error;
-            }
-            throw new V1InvalidPayloadError(`Failed to build signature message: ${error.message}`);
-        }
-
-        let hash;
-        try {
-            hash = await PeerWallet.blake3(message);
-        } catch (error) {
-            throw new V1InvalidPayloadError('Failed to hash signature message.');
-        }
-
-        let verified = false;
-        try {
-            verified = PeerWallet.verify(signature, hash, remotePublicKey);
-        } catch (error) {
-            verified = false;
-        }
-        if (!verified) {
-            throw new V1SignatureInvalidError('signature verification failed.');
-        }
-    }
-
-    #buildSignatureMessage(payload) {
-        if (!Number.isInteger(payload.type)) {
-            throw new V1InvalidPayloadError('Operation type must be an integer.');
-        }
-        if (payload.type === 0) {
-            throw new V1InvalidPayloadError('Operation type is unspecified.');
-        }
-
-        const idBuf = idToBuffer(payload.id);
-        const tsBuf = timestampToBuffer(payload.timestamp);
-        const capsBuf = encodeCapabilities(payload.capabilities ?? []);
-
-        switch (payload.type) {
-            case NetworkOperationType.LIVENESS_REQUEST: {
-                const nonce = payload.liveness_request.nonce;
-                const signature = payload.liveness_request.signature;
-                const message = createMessage(payload.type, idBuf, tsBuf, nonce, capsBuf);
-                return {signature, message};
-            }
-            case NetworkOperationType.LIVENESS_RESPONSE: {
-                const nonce = payload.liveness_response.nonce;
-                const signature = payload.liveness_response.signature;
-                const result = payload.liveness_response.result;
-                const message = createMessage(payload.type, idBuf, tsBuf, nonce, safeWriteUInt32BE(result, 0), capsBuf);
-                return {signature, message};
-            }
-            case NetworkOperationType.BROADCAST_TRANSACTION_REQUEST: {
-                const data = payload.broadcast_transaction_request.data;
-                const nonce = payload.broadcast_transaction_request.nonce;
-                const signature = payload.broadcast_transaction_request.signature;
-                const message = createMessage(payload.type, idBuf, tsBuf, data, nonce, capsBuf);
-                return {signature, message};
-            }
-            case NetworkOperationType.BROADCAST_TRANSACTION_RESPONSE: {
-                const nonce = payload.broadcast_transaction_response.nonce;
-                const signature = payload.broadcast_transaction_response.signature;
-                const result = payload.broadcast_transaction_response.result;
-                const proofRaw = payload.broadcast_transaction_response.proof;
-                const proof = b4a.isBuffer(proofRaw) ? proofRaw : b4a.alloc(0);
-                const hasProof = proof.length > 0;
-                const timestampRaw = payload.broadcast_transaction_response.timestamp;
-                const timestamp = Number.isSafeInteger(timestampRaw) ? timestampRaw : 0;
-                const hasTimestamp = timestamp > 0;
-
-                if (result === ResultCode.OK) {
-                    if (!hasProof || !hasTimestamp) {
-                        throw new V1InvalidPayloadError('Result code OK requires non-empty proof and timestamp > 0.');
-                    }
-                } else if (result === ResultCode.TX_ACCEPTED_PROOF_UNAVAILABLE) {
-                    if (hasProof) {
-                        throw new V1InvalidPayloadError('Result code TX_ACCEPTED_PROOF_UNAVAILABLE requires empty proof.');
-                    }
-                    if (!hasTimestamp) {
-                        throw new V1InvalidPayloadError('Result code TX_ACCEPTED_PROOF_UNAVAILABLE requires timestamp > 0.');
-                    }
-                } else {
-                    if (hasProof) {
-                        throw new V1InvalidPayloadError('Non-OK result code requires empty proof.');
-                    }
-                    if (timestamp !== 0) {
-                        throw new V1InvalidPayloadError('Non-OK result code requires timestamp to be 0, except TX_ACCEPTED_PROOF_UNAVAILABLE.');
-                    }
-                }
-
-                const message = createMessage(
-                    payload.type,
-                    idBuf,
-                    tsBuf,
-                    nonce,
-                    proof,
-                    timestampToBuffer(timestamp),
-                    safeWriteUInt32BE(result, 0),
-                    capsBuf
-                );
-
-                return {signature, message};
-            }
-            default:
-                throw new V1UnexpectedError(`Unknown operation type: ${payload.type}`);
-        }
-    }
-
-    #selectCheckSchemaValidator(type) {
-        if (!Number.isInteger(type)) {
-            throw new V1InvalidPayloadError('Operation type must be an integer.');
-        }
-        if (type === 0) {
-            throw new V1InvalidPayloadError('Operation type is unspecified.');
-        }
-
-        switch (type) {
-            case NetworkOperationType.LIVENESS_REQUEST:
-                return this.#v1ValidationSchema.validateV1LivenessRequest.bind(this.#v1ValidationSchema);
-            case NetworkOperationType.LIVENESS_RESPONSE:
-                return this.#v1ValidationSchema.validateV1LivenessResponse.bind(this.#v1ValidationSchema);
-            case NetworkOperationType.BROADCAST_TRANSACTION_REQUEST:
-                return this.#v1ValidationSchema.validateV1BroadcastTransactionRequest.bind(this.#v1ValidationSchema);
-            case NetworkOperationType.BROADCAST_TRANSACTION_RESPONSE:
-                return this.#v1ValidationSchema.validateV1BroadcastTransactionResponse.bind(this.#v1ValidationSchema);
-            default:
-                throw new V1UnexpectedError(`Unknown operation type: ${type}`);
-        }
-    }
-
-    validatePeerCorrectness(remotePublicKey, pendingRequestServiceEntry) {
-        const senderPublicKeyHex = b4a.toString(remotePublicKey, 'hex');
-        if (senderPublicKeyHex !== pendingRequestServiceEntry.requestedTo) {
-            throw new V1InvalidPayloadError(
-                `Response sender mismatch. Expected ${pendingRequestServiceEntry.requestedTo}, got ${senderPublicKeyHex}.`
-            );
-        }
-    }
-
-    validateResponseType(payload, pendingRequestServiceEntry) {
-        let expectedResponseType;
-        switch (pendingRequestServiceEntry.requestType) {
-            case NetworkOperationType.LIVENESS_REQUEST:
-                expectedResponseType = NetworkOperationType.LIVENESS_RESPONSE;
-                break;
-            case NetworkOperationType.BROADCAST_TRANSACTION_REQUEST:
-                expectedResponseType = NetworkOperationType.BROADCAST_TRANSACTION_RESPONSE;
-                break;
-            default:
-                throw new V1UnexpectedError(`Unsupported pending request type: ${pendingRequestServiceEntry.requestType}.`);
-        }
-
-        if (payload.type !== expectedResponseType) {
-            throw new V1InvalidPayloadError(
-                `Response type mismatch for id ${pendingRequestServiceEntry.id}. Expected ${expectedResponseType}, got ${payload.type}.`
-            );
-        }
-    }
-
-}
-
-export default V1BaseOperation;