trac-msb 0.2.26 → 0.3.0-beta.2

package/src/core/network/protocols/consensus/v1/handlers/V1EpochProofProposalOperationHandler.js

@@ -0,0 +1,226 @@
+import V1EpochProofProposalRequest from "../validators/V1EpochProofProposalRequest.js";
+import V1EpochProofProposalApproval from "../validators/V1EpochProofProposalApproval.js";
+import { getResultCode } from "../V1ConsensusProtocolError.js"
+import { ConsensusResultCode, CustomEventType } from "../../../../../../utils/constants.js";
+import { consensusMessageFactory } from "../../../../../../messages/consensus/v1/consensusMessageFactory.js";
+import { bufferToAddress } from "../../../../../state/utils/address.js"
+import ConnectionOperationHandler from "../../../shared/ConnectionOperationHandler.js";
+import { publicKeyToAddress } from "../../../../../../utils/helpers.js";
+
+
+class V1EpochProofProposalOperationHandler extends ConnectionOperationHandler {
+    #proofProposalRequestValidator;
+    #proofProposalApprovalValidator;
+    #wallet;
+    #state;
+    #connectionPolicy;
+
+    constructor(state, wallet, config, connectionPolicy) {
+        super(config)
+        this.#state = state;
+        this.#wallet = wallet;
+        this.#connectionPolicy = connectionPolicy;
+        this.#proofProposalRequestValidator = new V1EpochProofProposalRequest(config, state);
+        this.#proofProposalApprovalValidator = new V1EpochProofProposalApproval(config, state);
+    }
+
+    /**
+     * Handles a leader's consensus v1 epoch proof proposal from the minion side.
+     * @param {object} message Decoded consensus v1 message containing `proof_proposal` and `session_id`.
+     * @param {object} connection Peer connection context used by the request validator.
+     * @param protocolSession Protocol session context used by the request validator.
+     * @returns {Promise<void>} Resolves after responding, unless the consensus session is closed or the peer is banned.
+     */
+    async handleRequest(message, connection, protocolSession) {
+        const eventContext = this.#buildRequestEventContext(message, connection);
+        this.#emitEvent(CustomEventType.EPOCH_PROPOSAL_RECEIVED, eventContext);
+
+        let resultCode = ConsensusResultCode.OK;
+        let validationError;
+        let proofProposal;
+        try {
+            await this.#proofProposalRequestValidator.validate(message, connection);
+            proofProposal = message.proof_proposal;
+            this.#emitEvent(CustomEventType.EPOCH_PROPOSAL_VALIDATION_SUCCESS, {
+                ...eventContext,
+                resultCode,
+                proofProposal
+            });
+        } catch (e) {
+            validationError = e;
+            resultCode = getResultCode(e);
+            this.#emitEvent(CustomEventType.EPOCH_PROPOSAL_VALIDATION_FAILURE, {
+                ...eventContext,
+                resultCode,
+                error: validationError
+            });
+        }
+        finally {
+            if (!this.#connectionPolicy.requestPeerBan(connection, validationError)) {
+                await this.#sendEpochProofProposalApprovalResponse(
+                    message?.session_id,
+                    connection,
+                    protocolSession,
+                    message,
+                    resultCode
+                );
+            }
+        }
+    }
+
+    /**
+     * Handles a minion's consensus v1 epoch proof proposal approval from the requester side.
+     *
+     * Failure events include `error` only for locally detected validation failures;
+     * authenticated peer rejections carry their result code without an error.
+     *
+     * @param {object} message Decoded consensus v1 message containing `proof_proposal_response`.
+     * @param {object} connection Peer connection context used by the response validator.
+     * @param _protocolSession Protocol session context used by the response validator.
+     * @param {object} proofProposal Original proof proposal used by the response validator.
+     * @returns {Promise<{resultCode: number, approval?: object}>} Approval handling outcome with a ConsensusResultCode value.
+     */
+
+    async handleApproval(
+        message,
+        connection,
+        _protocolSession,
+        proofProposal
+    ) {
+        const eventContext = this.#buildApprovalEventContext(message, connection, proofProposal);
+        this.#emitEvent(CustomEventType.EPOCH_PROPOSAL_APPROVAL_RECEIVED, eventContext); // NOTE: Maybe not needed. Investigate. For now, this will be only a placeholder
+
+        let result;
+        try {
+            result = await this.#proofProposalApprovalValidator.validate(message, connection, proofProposal);
+        } catch (error) {
+            const resultCode = getResultCode(error);
+            this.#emitEvent(CustomEventType.EPOCH_PROPOSAL_APPROVAL_FAILURE, {
+                ...eventContext,
+                resultCode,
+                error: error
+            });
+            this.#connectionPolicy.requestPeerBan(connection, error);
+            return { resultCode };
+        }
+
+        const event = result.resultCode === ConsensusResultCode.OK
+            ? CustomEventType.EPOCH_PROPOSAL_APPROVAL_SUCCESS
+            : CustomEventType.EPOCH_PROPOSAL_APPROVAL_FAILURE;
+
+        this.#emitEvent(event, {
+            ...eventContext,
+            ...result
+        });
+        return result;
+    }
+
+    #buildRequestEventContext(message, connection) {
+        const remotePublicKey = connection?.remotePublicKey;
+
+        return {
+            message,
+            connection,
+            sessionId: message?.session_id,
+            remotePublicKey,
+        };
+    }
+
+    // TODO: This function is mostly copy-past from the one above. Refactor
+    #buildApprovalEventContext(message, connection, proofProposal) {
+        const remotePublicKey = connection?.remotePublicKey;
+
+        return {
+            message,
+            connection,
+            sessionId: message?.session_id,
+            remotePublicKey,
+            proofProposal
+        };
+    }
+
+    #emitEvent(eventName, context) {
+        try {
+            this.#state.emit(eventName, context);
+        } catch (error) {
+            this.displayError(`failed to emit ${eventName}`, context?.remotePublicKey, error);
+        }
+    }
+
+    async #buildProofProposalApproval(sessionId, proofProposal, resultCode) {
+        const proposer = bufferToAddress(proofProposal.proposer, this.config.addressPrefix);
+
+        // TODO: In here we are basically getting some fields represented as buffers from
+        // the received proofProposal, converting them to numbers, just to convert them
+        // back to buffers internally. This should be optimized
+        return await consensusMessageFactory(this.#wallet, this.config).buildProofProposalResponse(
+            sessionId,
+            proofProposal.network_id.readUInt16BE(0),
+            proofProposal.epoch.readBigUInt64BE(0),
+            proofProposal.previous_epoch_record_hash,
+            proposer,
+            proofProposal.difficulty,
+            proofProposal.discriminant_bit_size,
+            proofProposal.proof,
+            proofProposal.signature,
+            resultCode,
+            this.#wallet.address
+        );
+    }
+
+    async #buildProofProposalRejection(sessionId, resultCode) {
+        return await consensusMessageFactory(this.#wallet, this.config).buildProofProposalRejectionResponse(
+            sessionId,
+            resultCode
+        );
+    }
+
+    #isValidResponseSessionId(sessionId) {
+        return typeof sessionId === 'string' && sessionId.length > 0 && sessionId.length <= 64;
+    }
+
+    async #sendEpochProofProposalApprovalResponse(
+        messageId,
+        connection,
+        protocolSession,
+        message,
+        resultCode
+    ) {
+        try {
+            if (protocolSession.closed) return;
+            if (!this.#isValidResponseSessionId(messageId)) {
+                const sender = publicKeyToAddress(connection.remotePublicKey, this.config);
+                this.#connectionPolicy.handleInvalidMessage(protocolSession, `${this.constructor.name}: invalid Consensus V1 message session_id, sender: ${sender}`);
+                return;
+            }
+
+            const response = resultCode === ConsensusResultCode.OK
+                ? await this.#buildProofProposalApproval(
+                    messageId,
+                    message.proof_proposal,
+                    resultCode,
+                )
+                : await this.#buildProofProposalRejection(
+                    messageId,
+                    resultCode
+                );
+
+            if (!protocolSession.closed) protocolSession.sendAndForget(response);
+
+        } catch (error) {
+            this.displayError(
+                "failed to build/send response to sender",
+                connection.remotePublicKey,
+                error
+            );
+        }
+    }
+
+    displayError(step, senderPublicKey, error) {
+        const sender = publicKeyToAddress(senderPublicKey, this.config);
+        this.#connectionPolicy.handleLocalError(`${this.constructor.name}: Consensus V1 message ${step}, sender: ${sender}: ${error?.message ?? 'Unexpected error'}`);
+    }
+
+}
+
+export default V1EpochProofProposalOperationHandler;

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

@@ -0,0 +1,192 @@
+import Validator from 'fastest-validator';
+import {
+    HASH_BYTE_LENGTH,
+    PUBLIC_KEY_LENGTH,
+    CONSENSUS_REQUEST_ID_MAX_LENGTH,
+    CONSENSUS_SESSION_ID_MAX_LENGTH,
+    ConsensusOperationType,
+    SIGNATURE_BYTE_LENGTH,
+    ConsensusResultCode,
+    NETWORK_ID_BYTE_LENGTH,
+    EPOCH_BYTE_LENGTH,
+    VDF_DIFFICULTY_SIZE,
+    VDF_DISCRIMINANT_SIZE
+} from '../../../../../../utils/constants.js';
+import { EPOCH_APPENDER_SELECTION_VERSION, EpochAppenderVoteStatus } from '../../../../../consensus/epochAppenderSelection/epochAppenderSelectionState.js';
+import {
+    compileBufferRule,
+    validateSelectionCounter,
+    validateProofProposalLength,
+    validateProofProposalApprovalPresence,
+} from './consensusValidationSchemaHelpers.js';
+
+const ALLOWED_RESULT_CODES = Object.values(ConsensusResultCode);
+
+class ConsensusValidationSchema {
+    #config;
+    #validator;
+    #validateConsensusV1ProofProposalSchema;
+    #validateConsensusV1ProposalApprovalSchema;
+    #validateEpochAppendRequestSchema;
+    #validateEpochAppendReplySchema;
+    #epochAppendIntentSchema;
+
+    constructor(config) {
+        this.#config = config;
+        this.#validator = new Validator({
+            useNewCustomCheckerFunction: true,
+            messages: {
+                buffer: "The '{field}' field must be a Buffer! Actual: {actual}",
+                bufferLength: "The '{field}' field must be a Buffer with length {expected}! Actual: {actual}",
+                bufferMinLength: "The '{field}' field must be a Buffer with min length {expected}! Actual: {actual}",
+                bufferMaxLength: "The '{field}' field must be a Buffer with max length {expected}! Actual: {actual}",
+                nonZeroBuffer: "The '{field}' field must not be an empty or zero-filled Buffer!",
+                emptyBuffer: "The '{field}' field must not be an empty Buffer! Actual: {actual}",
+                uint64: "The '{field}' field must be an unsigned 64-bit integer! Actual: {actual}",
+            },
+        });
+        this.#validator.add('buffer', compileBufferRule);
+        this.#epochAppendIntentSchema = {
+            type: 'object',
+            strict: true,
+            props: {
+                network_id: { type: 'buffer', length: NETWORK_ID_BYTE_LENGTH, required: true },
+                bootstrap: { type: 'buffer', length: HASH_BYTE_LENGTH, required: true },
+                epoch: { type: 'buffer', length: EPOCH_BYTE_LENGTH, required: true },
+                parent_hash: { type: 'buffer', length: HASH_BYTE_LENGTH, required: true },
+                membership_context: { type: 'buffer', length: HASH_BYTE_LENGTH, required: true },
+                config_hash: { type: 'buffer', length: HASH_BYTE_LENGTH, required: true },
+                request_id: { type: 'string', min: 1, max: CONSENSUS_REQUEST_ID_MAX_LENGTH, required: true },
+                payload_hash: { type: 'buffer', length: HASH_BYTE_LENGTH, required: true },
+                logical_counter: { type: 'buffer', length: EPOCH_BYTE_LENGTH, required: true, custom: validateSelectionCounter },
+                requester: { type: 'buffer', length: PUBLIC_KEY_LENGTH, required: true },
+                selection_version: { type: 'equal', value: EPOCH_APPENDER_SELECTION_VERSION, required: true },
+            },
+        };
+        this.#validateConsensusV1ProofProposalSchema = this.#compileV1EpochProofProposalRequestSchema();
+        this.#validateConsensusV1ProposalApprovalSchema = this.#compileConsensusV1ProposalApprovalSchema();
+        this.#validateEpochAppendRequestSchema = this.#compileEpochAppendRequestSchema();
+        this.#validateEpochAppendReplySchema = this.#compileEpochAppendReplySchema();
+    }
+
+    #compileV1EpochProofProposalRequestSchema() {
+        const schema = {
+            $$strict: true,
+            type: {
+                type: 'number',
+                integer: true,
+                equal: ConsensusOperationType.PROOF_PROPOSAL,
+                required: true
+            },
+            session_id: { type: 'string', min: 1, max: CONSENSUS_SESSION_ID_MAX_LENGTH, required: true },
+            timestamp: { type: 'number', integer: true, min: 1, max: Number.MAX_SAFE_INTEGER, required: true },
+            proof_proposal: {
+                strict: true,
+                type: 'object',
+                props: {
+                    network_id: { type: 'buffer', length: NETWORK_ID_BYTE_LENGTH, required: true },
+                    epoch: { type: 'buffer', length: EPOCH_BYTE_LENGTH, required: true },
+                    previous_epoch_record_hash: { type: 'buffer', length: HASH_BYTE_LENGTH, required: true },
+                    proposer: { type: 'buffer', length: this.#config.addressLength, required: true },
+                    difficulty: { type: 'buffer', length: VDF_DIFFICULTY_SIZE, required: true },
+                    discriminant_bit_size: { type: 'buffer', length: VDF_DISCRIMINANT_SIZE, required: true },
+                    proof: { type: 'buffer', required: true },
+                    signature: { type: 'buffer', length: SIGNATURE_BYTE_LENGTH, required: true },
+                },
+                custom: validateProofProposalLength,
+            },
+        };
+        return this.#validator.compile(schema);
+    }
+
+    validateConsensusV1ProofProposal(operation) {
+        return this.#validateConsensusV1ProofProposalSchema(operation) === true;
+    }
+
+    #compileConsensusV1ProposalApprovalSchema() {
+        const schema = {
+            $$strict: true,
+            type: {
+                type: 'number',
+                integer: true,
+                equal: ConsensusOperationType.PROOF_PROPOSAL_APPROVAL,
+                required: true
+            },
+            session_id: { type: 'string', min: 1, max: CONSENSUS_SESSION_ID_MAX_LENGTH, required: true },
+            timestamp: { type: 'number', integer: true, min: 1, max: Number.MAX_SAFE_INTEGER, required: true },
+            proof_proposal_response: {
+                strict: true,
+                type: 'object',
+                props: {
+                    result: { type: 'enum', values: ALLOWED_RESULT_CODES, required: true },
+                    approval: {
+                        strict: true,
+                        type: 'object',
+                        optional: true,
+                        props: {
+                            approver: { type: 'buffer', length: this.#config.addressLength, required: true },
+                            approval_sig: { type: 'buffer', length: SIGNATURE_BYTE_LENGTH, required: true },
+                        }
+                    },
+                    response_sig: { type: 'buffer', length: SIGNATURE_BYTE_LENGTH, required: true },
+                },
+                custom: validateProofProposalApprovalPresence,
+            },
+        };
+        return this.#validator.compile(schema);
+    }
+
+    validateV1EpochProofProposalResponse(operation) {
+        return this.#validateConsensusV1ProposalApprovalSchema(operation) === true;
+    }
+
+    #compileEpochAppendRequestSchema() {
+        const schema = {
+            $$strict: true,
+            type: { type: 'number', integer: true, equal: ConsensusOperationType.REQUEST, required: true },
+            session_id: { type: 'string', min: 1, max: CONSENSUS_SESSION_ID_MAX_LENGTH, required: true },
+            timestamp: { type: 'number', integer: true, min: 1, max: Number.MAX_SAFE_INTEGER, required: true },
+            request: {
+                type: 'object',
+                strict: true,
+                props: {
+                    intent: this.#epochAppendIntentSchema,
+                    signature: { type: 'buffer', length: SIGNATURE_BYTE_LENGTH, required: true },
+                },
+            },
+        };
+        return this.#validator.compile(schema);
+    }
+
+    validateEpochAppendRequest(operation) {
+        return this.#validateEpochAppendRequestSchema(operation) === true;
+    }
+
+    #compileEpochAppendReplySchema() {
+        const schema = {
+            $$strict: true,
+            type: { type: 'number', integer: true, equal: ConsensusOperationType.REPLY, required: true },
+            session_id: { type: 'string', min: 1, max: CONSENSUS_SESSION_ID_MAX_LENGTH, required: true },
+            timestamp: { type: 'number', integer: true, min: 1, max: Number.MAX_SAFE_INTEGER, required: true },
+            reply: {
+                type: 'object',
+                strict: true,
+                props: {
+                    intent: this.#epochAppendIntentSchema,
+                    signature: { type: 'buffer', length: SIGNATURE_BYTE_LENGTH, required: true },
+                    responder: { type: 'buffer', length: PUBLIC_KEY_LENGTH, required: true },
+                    vote_status: { type: 'enum', values: Object.values(EpochAppenderVoteStatus), required: true },
+                    observed_counter: { type: 'buffer', length: EPOCH_BYTE_LENGTH, required: true, custom: validateSelectionCounter },
+                    vote: this.#epochAppendIntentSchema,
+                },
+            },
+        };
+        return this.#validator.compile(schema);
+    }
+
+    validateEpochAppendReply(operation) {
+        return this.#validateEpochAppendReplySchema(operation) === true;
+    }
+}
+
+export default ConsensusValidationSchema;