trac-msb 0.2.11 → 0.2.12

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

@@ -1,26 +0,0 @@
-import V1BaseOperation from "./V1BaseOperation.js";
-import b4a from "b4a";
-import { MAX_PARTIAL_TX_PAYLOAD_BYTE_SIZE } from '../../../../../utils/constants.js';
-import {V1InvalidPayloadError} from "../V1ProtocolError.js";
-
-class V1BroadcastTransactionRequest extends V1BaseOperation {
-    constructor(config) {
-        super(config);
-    }
-
-    async validate(payload, remotePublicKey) {
-        this.isPayloadSchemaValid(payload);
-        this.isDataPropertySizeValid(payload);
-        await this.validateSignature(payload, remotePublicKey);
-        return true;
-    }
-
-    isDataPropertySizeValid(payload) {
-        if (b4a.byteLength(payload.broadcast_transaction_request.data) > MAX_PARTIAL_TX_PAYLOAD_BYTE_SIZE) {
-            throw new V1InvalidPayloadError(`The 'data' field exceeds the maximum allowed byte size of ${MAX_PARTIAL_TX_PAYLOAD_BYTE_SIZE}. Actual size: ${b4a.byteLength(payload.broadcast_transaction_request.data)}`);
-        }
-    }
-
-}
-
-export default V1BroadcastTransactionRequest;

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

@@ -1,276 +0,0 @@
-import Autobase from "autobase";
-import b4a from "b4a";
-import Hypercore from 'hypercore';
-import V1BaseOperation from "./V1BaseOperation.js";
-import {unsafeDecodeApplyOperation} from "../../../../../utils/protobuf/operationHelpers.js";
-import {isDeepEqualApplyPayload} from "../../../../../utils/deepEqualApplyPayload.js";
-import {addressToBuffer, bufferToAddress} from "../../../../state/utils/address.js";
-import {publicKeyToAddress} from "../../../../../utils/helpers.js";
-import Check from "../../../../../utils/check.js";
-import {OperationType, ResultCode} from "../../../../../utils/constants.js";
-import {V1ProtocolError} from "../V1ProtocolError.js";
-
-const VALIDATOR_METADATA_FIELDS = new Set(["va", "vn", "vs"]);
-
-class V1BroadcastTransactionResponse extends V1BaseOperation {
-    #config;
-    #check;
-    #state;
-
-    constructor(state, config) {
-        super(config);
-        this.#state = state;
-        this.#config = config;
-        this.#check = new Check(config);
-    }
-
-    async validate(payload, connection, pendingRequestServiceEntry) {
-        this.isPayloadSchemaValid(payload);
-        this.validateResponseType(payload, pendingRequestServiceEntry);
-        this.validatePeerCorrectness(connection.remotePublicKey, pendingRequestServiceEntry);
-        await this.validateSignature(payload, connection.remotePublicKey);
-        const resultCode = payload.broadcast_transaction_response.result;
-        // if result code is not OK, we can skip the rest of the validations.
-        this.validateIfResultCodeIsValidatorInternalError(resultCode);
-        if (resultCode === ResultCode.OK) {
-            const proofResult = await this.verifyProofOfPublication(payload);
-            const {
-                validatorDecodedTx,
-                manifest
-            } = await this.assertProofPayloadMatchesRequestPayload(proofResult, pendingRequestServiceEntry);
-            this.validateDecodedCompletePayloadSchema(validatorDecodedTx);
-            const {
-                writerKeyFromManifest,
-                validatorAddressCorrelatedWithManifest
-            } = await this.validateWritingKey(validatorDecodedTx, manifest);
-            await this.validateValidatorCorrectness(
-                validatorDecodedTx,
-                connection.remotePublicKey,
-                writerKeyFromManifest,
-                validatorAddressCorrelatedWithManifest,
-            );
-        }
-
-        return true;
-    }
-
-    validateDecodedCompletePayloadSchema(validatorDecodedTx) {
-        const type = validatorDecodedTx?.type;
-        if (!Number.isInteger(type)) {
-            throw new V1ProtocolError(
-                ResultCode.VALIDATOR_RESPONSE_TX_TYPE_INVALID,
-                'Decoded validator transaction type is missing or invalid.',
-                false
-            );
-        }
-
-        if (!Object.values(OperationType).includes(type)) {
-            throw new V1ProtocolError(
-                ResultCode.VALIDATOR_RESPONSE_TX_TYPE_UNKNOWN,
-                `Decoded validator transaction type ${type} is not defined in OperationType constants.`,
-                false
-            );
-        }
-
-        let isValid = false;
-        switch (type) {
-            case OperationType.ADD_WRITER:
-            case OperationType.REMOVE_WRITER:
-            case OperationType.ADMIN_RECOVERY:
-                isValid =  this.#check.validateRoleAccessOperation(validatorDecodedTx);
-                break;
-            case OperationType.BOOTSTRAP_DEPLOYMENT:
-                isValid =  this.#check.validateBootstrapDeploymentOperation(validatorDecodedTx);
-                break;
-            case OperationType.TX:
-                isValid = this.#check.validateTransactionOperation(validatorDecodedTx);
-                break;
-            case OperationType.TRANSFER:
-                isValid = this.#check.validateTransferOperation(validatorDecodedTx);
-                break;
-            default:
-                throw new V1ProtocolError(
-                    ResultCode.VALIDATOR_RESPONSE_TX_TYPE_UNSUPPORTED,
-                    `Unsupported decoded validator transaction type: ${type}`,
-                    false
-                );
-        }
-
-        if (!isValid) {
-            throw new V1ProtocolError(
-                ResultCode.VALIDATOR_RESPONSE_SCHEMA_INVALID,
-                `Decoded validator transaction schema validation failed for type ${type}.`,
-                false
-            );
-        }
-    }
-
-    async verifyProofOfPublication(payload) {
-        const proof = payload.broadcast_transaction_response.proof;
-        return this.#state.verifyProofOfPublication(proof);
-    }
-
-    async assertProofPayloadMatchesRequestPayload(proofResult, pendingRequestServiceEntry) {
-        const stateTxEncodedFromRequest = pendingRequestServiceEntry.requestTxData;
-        if (!b4a.isBuffer(stateTxEncodedFromRequest) || stateTxEncodedFromRequest.length === 0) {
-            throw new V1ProtocolError(
-                ResultCode.PENDING_REQUEST_MISSING_TX_DATA,
-                'Missing transaction data in pending request entry.',
-                false
-            );
-        }
-        const provenBlock = proofResult.proof.block.value;
-        const manifest = proofResult.proof.manifest;
-        const stateTxEncodedFromResponse = await Autobase.decodeValue(provenBlock);
-
-        const stateTxDecodedFromRequest = unsafeDecodeApplyOperation(stateTxEncodedFromRequest);
-        const stateTxDecodedFromResponse = unsafeDecodeApplyOperation(stateTxEncodedFromResponse);
-        const strippedValidatorPayload = stripValidatorMetadata(stateTxDecodedFromResponse);
-
-        if (!isDeepEqualApplyPayload(stateTxDecodedFromRequest, strippedValidatorPayload)) {
-            throw new V1ProtocolError(
-                ResultCode.PROOF_PAYLOAD_MISMATCH,
-                'Decoded transaction payload mismatch after removing validator metadata fields.',
-                false
-            );
-        }
-        return {validatorDecodedTx: stateTxDecodedFromResponse, manifest};
-    }
-
-    async validateWritingKey(validatorDecodedTx, manifest) {
-        const writerKeyFromManifest = Hypercore.key(manifest);
-        const writerKeyFromManifestHex = b4a.toString(writerKeyFromManifest, "hex");
-
-        const validatorAddressBuffer = await this.#state.getRegisteredWriterKey(writerKeyFromManifestHex);
-        if (!b4a.isBuffer(validatorAddressBuffer) || validatorAddressBuffer.length === 0) {
-            throw new V1ProtocolError(
-                ResultCode.VALIDATOR_WRITER_KEY_NOT_REGISTERED,
-                `Validator with writer key ${writerKeyFromManifestHex} is not registered.`,
-                false
-            );
-        }
-
-        return {
-            writerKeyFromManifest,
-            validatorAddressCorrelatedWithManifest: validatorAddressBuffer
-        };
-    }
-
-    async validateValidatorCorrectness(validatorDecodedTx, connectionRemotePublicKey, writerKeyFromManifest, validatorAddressCorrelatedWithManifest) {
-        const validatorAddressFromTx = extractRequiredVaFromDecodedTx(validatorDecodedTx);
-        const validatorAddressFromConnectionPublicKey = addressToBuffer(
-            publicKeyToAddress(connectionRemotePublicKey, this.#config),
-            this.#config.addressPrefix
-        );
-
-        if (!b4a.equals(validatorAddressFromTx, validatorAddressFromConnectionPublicKey)) {
-            throw new V1ProtocolError(
-                ResultCode.VALIDATOR_ADDRESS_MISMATCH,
-                `Validator address from transaction (${bufferToAddress(validatorAddressFromTx, this.#config.addressPrefix)}) does not match address derived from connection public key (${bufferToAddress(validatorAddressFromConnectionPublicKey, this.#config.addressPrefix)}).`,
-                false
-            );
-        }
-
-        if (!b4a.equals(validatorAddressFromTx, validatorAddressCorrelatedWithManifest)) {
-            throw new V1ProtocolError(
-                ResultCode.VALIDATOR_ADDRESS_MISMATCH,
-                `Validator address from transaction (${bufferToAddress(validatorAddressFromTx, this.#config.addressPrefix)}) does not match address correlated with manifest writer key (${bufferToAddress(validatorAddressCorrelatedWithManifest, this.#config.addressPrefix)}).`,
-                false
-            );
-        }
-
-        if (!b4a.equals(validatorAddressCorrelatedWithManifest, validatorAddressFromConnectionPublicKey)) {
-            throw new V1ProtocolError(
-                ResultCode.VALIDATOR_ADDRESS_MISMATCH,
-                `Validator address correlated with manifest writer key (${bufferToAddress(validatorAddressCorrelatedWithManifest, this.#config.addressPrefix)}) does not match address derived from connection public key (${bufferToAddress(validatorAddressFromConnectionPublicKey, this.#config.addressPrefix)}).`,
-                false
-            );
-        }
-
-        const validatorAddressFromConnection = bufferToAddress(validatorAddressFromConnectionPublicKey, this.#config.addressPrefix);
-        const account = await this.#state.getNodeEntry(validatorAddressFromConnection);
-
-        if (!account) {
-            throw new V1ProtocolError(
-                ResultCode.VALIDATOR_NODE_ENTRY_NOT_FOUND,
-                `No node entry found in state for validator address derived from connection public key (${validatorAddressFromConnection}).`,
-                false
-            );
-        }
-
-        if (!account.isWriter) {
-            throw new V1ProtocolError(
-                ResultCode.VALIDATOR_NODE_NOT_WRITER,
-                `Node entry found for validator address derived from connection public key (${validatorAddressFromConnection}), but it is not registered as a writer.`,
-                false
-            );
-        }
-
-        if (!b4a.isBuffer(account.wk) || !b4a.equals(account.wk, writerKeyFromManifest)) {
-            throw new V1ProtocolError(
-                ResultCode.VALIDATOR_WRITER_KEY_MISMATCH,
-                `Writer key from manifest (${b4a.toString(writerKeyFromManifest, "hex")}) does not match writer key in state for validator address derived from connection public key (${validatorAddressFromConnection}).`,
-                false
-            );
-        }
-    }
-
-    validateIfResultCodeIsValidatorInternalError(resultCode) {
-        if (resultCode === ResultCode.TX_COMMITTED_RECEIPT_MISSING) {
-            throw new V1ProtocolError(
-                resultCode,
-                `Validator response indicates an error with result code ${resultCode}, which is an internal error code.`,
-                true
-            )
-        }
-    }
-}
-
-const stripValidatorMetadata = (value) => {
-
-    if (value === null || value === undefined) return value;
-    if (b4a.isBuffer(value)) return value;
-    if (Array.isArray(value)) return value.map(stripValidatorMetadata);
-    if (typeof value !== "object") return value;
-
-    const result = {};
-    for (const [key, nestedValue] of Object.entries(value)) {
-        if (VALIDATOR_METADATA_FIELDS.has(key)) {
-            result[key] = null;
-            continue;
-        }
-        result[key] = stripValidatorMetadata(nestedValue);
-    }
-    return result;
-};
-
-export function extractRequiredVaFromDecodedTx(validatorDecodedTx) {
-    if (!validatorDecodedTx || typeof validatorDecodedTx !== 'object') {
-        throw new V1ProtocolError(
-            ResultCode.VALIDATOR_TX_OBJECT_INVALID,
-            'Invalid decoded transaction: expected object',
-            false
-        );
-    }
-
-    const operationPayload = Object.values(validatorDecodedTx).find((value) =>
-        value &&
-        typeof value === 'object' &&
-        !Array.isArray(value) &&
-        !b4a.isBuffer(value) &&
-        Object.prototype.hasOwnProperty.call(value, 'va')
-    );
-
-    const va = operationPayload?.va;
-
-    if (!b4a.isBuffer(va)) {
-        throw new V1ProtocolError(
-            ResultCode.VALIDATOR_VA_MISSING,
-            'Missing validator address (va) in decoded transaction',
-            false
-        );
-    }
-    return va;
-}
-
-export default V1BroadcastTransactionResponse;

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

@@ -1,15 +0,0 @@
-import V1BaseOperation from "./V1BaseOperation.js";
-
-class V1LivenessRequest extends V1BaseOperation {
-    constructor(config) {
-        super(config);
-    }
-
-    async validate(payload, remotePublicKey) {
-        this.isPayloadSchemaValid(payload);
-        await this.validateSignature(payload, remotePublicKey);
-        return true;
-    }
-}
-
-export default V1LivenessRequest;

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

@@ -1,17 +0,0 @@
-import V1BaseOperation from "./V1BaseOperation.js";
-
-class V1LivenessResponse extends V1BaseOperation {
-    constructor(config) {
-        super(config);
-    }
-
-    async validate(payload, connection, pendingRequestServiceEntry) {
-        this.isPayloadSchemaValid(payload);
-        this.validateResponseType(payload, pendingRequestServiceEntry);
-        this.validatePeerCorrectness(connection.remotePublicKey, pendingRequestServiceEntry);
-        await this.validateSignature(payload, connection.remotePublicKey);
-        return true;
-    }
-}
-
-export default V1LivenessResponse;

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

@@ -1,210 +0,0 @@
-import Validator from 'fastest-validator';
-import b4a from 'b4a';
-import {
-    NetworkOperationType,
-    NONCE_BYTE_LENGTH,
-    SIGNATURE_BYTE_LENGTH,
-    MAX_PARTIAL_TX_PAYLOAD_BYTE_SIZE,
-    ResultCode
-} from '../../../../../utils/constants.js';
-
-const ALLOWED_RESULT_CODES = Object.values(ResultCode);
-
-class V1ValidationSchema {
-    #validator;
-    #validateV1LivenessRequest;
-    #validateV1LivenessResponse;
-    #validateV1BroadcastTransactionRequest;
-    #validateV1BroadcastTransactionResponse;
-
-    constructor() {
-        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}",
-            },
-        });
-        const isBuffer = b4a.isBuffer;
-        this.#validator.add("buffer", function ({schema, messages}, path, context) {
-            const allowZero = schema.allowZero === true;
-            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;
-                        }
-                        if (!${allowZero}) {
-                            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;
-                    `
-            };
-        });
-
-        this.#validateV1LivenessRequest = this.#compileV1LivenessRequestSchema();
-        this.#validateV1LivenessResponse = this.#compileV1LivenessResponseSchema();
-        this.#validateV1BroadcastTransactionRequest = this.#compileV1BroadcastTransactionRequestSchema();
-        this.#validateV1BroadcastTransactionResponse = this.#compileV1BroadcastTransactionResponseSchema();
-    }
-
-    #compileV1LivenessRequestSchema() {
-        const schema = {
-            $$strict: true,
-            type: {type: 'number', integer: true, equal: NetworkOperationType.LIVENESS_REQUEST, required: true},
-            id: {type: 'string', min: 1, max: 64, required: true},
-            timestamp: {type: 'number', integer: true, min: 1, max: Number.MAX_SAFE_INTEGER, required: true},
-            liveness_request: {
-                strict: true,
-                type: 'object',
-                props: {
-                    nonce: {type: 'buffer', length: NONCE_BYTE_LENGTH, required: true},
-                    signature: {type: 'buffer', length: SIGNATURE_BYTE_LENGTH, required: true},
-                }
-            },
-            capabilities: {type: 'array', items: 'string', required: true},
-
-        };
-        return this.#validator.compile(schema);
-    }
-
-    validateV1LivenessRequest(operation) {
-        return this.#validateV1LivenessRequest(operation) === true;
-    }
-
-    #compileV1LivenessResponseSchema() {
-        const schema = {
-            $$strict: true,
-            type: {type: 'number', integer: true, equal: NetworkOperationType.LIVENESS_RESPONSE, required: true},
-            id: {type: 'string', min: 1, max: 64, required: true},
-            timestamp: {type: 'number', integer: true, min: 1, max: Number.MAX_SAFE_INTEGER, required: true},
-            liveness_response: {
-                strict: true,
-                type: 'object',
-                props: {
-                    nonce: {type: 'buffer', length: NONCE_BYTE_LENGTH, required: true},
-                    signature: {type: 'buffer', length: SIGNATURE_BYTE_LENGTH, required: true},
-                    result: {type: 'enum', values: ALLOWED_RESULT_CODES, required: true},
-                }
-            },
-            capabilities: {type: 'array', items: 'string', required: true},
-
-        };
-        return this.#validator.compile(schema);
-    }
-
-    validateV1LivenessResponse(operation) {
-        return this.#validateV1LivenessResponse(operation) === true;
-    }
-
-    #compileV1BroadcastTransactionRequestSchema() {
-        const schema = {
-            $$strict: true,
-            type: {
-                type: 'number',
-                integer: true,
-                equal: NetworkOperationType.BROADCAST_TRANSACTION_REQUEST,
-                required: true
-            },
-            id: {type: 'string', min: 1, max: 64, required: true},
-            timestamp: {type: 'number', integer: true, min: 1, max: Number.MAX_SAFE_INTEGER, required: true},
-            broadcast_transaction_request: {
-                strict: true,
-                type: 'object',
-                props: {
-                    data: {
-                        type: 'buffer',
-                        min: 1,
-                        max: MAX_PARTIAL_TX_PAYLOAD_BYTE_SIZE,
-                        allowZero: true,
-                        required: true
-                    },
-                    nonce: {type: 'buffer', length: NONCE_BYTE_LENGTH, required: true},
-                    signature: {type: 'buffer', length: SIGNATURE_BYTE_LENGTH, required: true},
-                }
-            },
-            capabilities: {type: 'array', items: 'string', required: true},
-
-        };
-        return this.#validator.compile(schema);
-    }
-
-    validateV1BroadcastTransactionRequest(operation) {
-        return this.#validateV1BroadcastTransactionRequest(operation) === true;
-    }
-
-    #compileV1BroadcastTransactionResponseSchema() {
-        const schema = {
-            $$strict: true,
-            type: {
-                type: 'number',
-                integer: true,
-                equal: NetworkOperationType.BROADCAST_TRANSACTION_RESPONSE,
-                required: true
-            },
-            id: {type: 'string', min: 1, max: 64, required: true},
-            timestamp: {type: 'number', integer: true, min: 1, max: Number.MAX_SAFE_INTEGER, required: true},
-            broadcast_transaction_response: {
-                strict: true,
-                type: 'object',
-                props: {
-                    nonce: {type: 'buffer', length: NONCE_BYTE_LENGTH, required: true},
-                    signature: {type: 'buffer', length: SIGNATURE_BYTE_LENGTH, required: true},
-                    proof: {type: 'buffer', allowEmpty: true, allowZero: true, required: true},
-                    timestamp: {
-                        type: 'number',
-                        integer: true,
-                        min: 0,
-                        max: Number.MAX_SAFE_INTEGER,
-                        optional: true
-                    },
-                    result: {type: 'enum', values: ALLOWED_RESULT_CODES, required: true},
-                }
-            },
-            capabilities: {type: 'array', items: 'string', required: true},
-
-        };
-        return this.#validator.compile(schema);
-    }
-
-    validateV1BroadcastTransactionResponse(operation) {
-        return this.#validateV1BroadcastTransactionResponse(operation) === true;
-    }
-}
-
-export default V1ValidationSchema;