trac-msb 0.2.26 → 0.3.0-beta.2

package/src/codecs/consensus/v1/consensusV1OperationCodec.js

@@ -0,0 +1,161 @@
+import b4a from 'b4a';
+import consensusV1Generated from './consensusV1.generated.cjs';
+
+const {
+    ConsensusMessageHeader,
+    ProofProposalApproval,
+    ProofProposal,
+    EpochAppendIntent,
+} = consensusV1Generated.consensus.v1;
+
+// Options for converting protobuf messages to plain objects, ensuring that bytes are returned as Buffers and enums as numbers.
+const CONSENSUS_TO_OBJECT_OPTIONS = Object.freeze({
+    enums: Number,
+    longs: Number,
+    defaults: false,
+    arrays: true,
+    oneofs: false
+});
+
+const encodeMessage = (Message, payload) => {
+    const error = Message.verify(payload);
+    if (error) throw new Error(error);
+    return b4a.from(Message.encode(payload).finish());
+}
+
+const decodeMessage = (Message, payload) => {
+    return Message.toObject(
+        Message.decode(payload),
+        CONSENSUS_TO_OBJECT_OPTIONS
+    );
+}
+
+/**
+ * Encodes a consensus v1 message header for regular consensus network messages.
+ *
+ * @param {Object} payload - ConsensusMessageHeader payload.
+ * @returns {Buffer} Encoded consensus message.
+ */
+export const encodeConsensusMessage = (payload) => {
+    return encodeMessage(ConsensusMessageHeader, payload);
+}
+
+/**
+ * Decodes a consensus v1 message header from regular consensus network messages.
+ *
+ * @param {Buffer} payload - Encoded ConsensusMessageHeader buffer.
+ * @returns {Object} Decoded consensus message.
+ */
+export const decodeConsensusMessage = (payload) => {
+    return decodeMessage(ConsensusMessageHeader, payload);
+}
+
+/**
+ * Encodes a ProofProposalApproval for regular consensus usage.
+ *
+ * @param {Object} payload - ProofProposalApproval payload.
+ * @returns {Buffer} Encoded approval.
+ */
+export const encodeProofProposalApproval = (payload) => {
+    return encodeMessage(ProofProposalApproval, payload);
+}
+
+/**
+ * Decodes a ProofProposalApproval for regular consensus usage.
+ *
+ * @param {Buffer} payload - Encoded ProofProposalApproval buffer.
+ * @returns {Object} Decoded approval.
+ */
+export const decodeProofProposalApproval = (payload) => {
+    return decodeMessage(ProofProposalApproval, payload);
+}
+
+/**
+ * Encodes a ProofProposal for regular consensus usage.
+ *
+ * @param {Object} payload - ProofProposalApproval payload.
+ * @returns {Buffer} Encoded approval.
+ */
+export const encodeProofProposal = (payload) => {
+    return encodeMessage(ProofProposal, payload);
+}
+
+/**
+ * Decodes a ProofProposal for regular consensus usage.
+ *
+ * @param {Buffer} payload - Encoded ProofProposal buffer.
+ * @returns {Object} Decoded .
+ */
+export const decodeProofProposal = (payload) => {
+    return decodeMessage(ProofProposal, payload);
+}
+
+/**
+ * Safely encodes a ProofProposalApproval for apply-function validation paths.
+ * Returns an empty buffer when the approval payload is invalid.
+ *
+ * @param {*} payload - Input expected to match ProofProposalApproval.
+ * @returns {Buffer} Encoded approval or an empty buffer.
+ */
+export const safeEncodeProofProposalApproval = (payload) => {
+    try {
+        return encodeProofProposalApproval(payload);
+    } catch (error) {
+        console.log("safeEncodeProofProposalApproval error:", error.message);
+    }
+
+    return b4a.alloc(0);
+}
+
+/**
+ * Safely decodes a ProofProposalApproval for apply-function validation paths.
+ * Returns null when the input is not a buffer or cannot be decoded.
+ *
+ * @param {*} payload - Encoded ProofProposalApproval buffer.
+ * @returns {Object|null} Decoded approval or null.
+ */
+export const safeDecodeProofProposalApproval = (payload) => {
+    try {
+        if (!b4a.isBuffer(payload)) return null;
+        return decodeProofProposalApproval(payload);
+    } catch (error) {
+        console.log("safeDecodeProofProposalApproval error:", error.message);
+    }
+    return null;
+}
+
+/**
+ * Safely encodes a ProofProposal for apply-function validation paths.
+ * Returns an empty buffer when the payload is invalid.
+ *
+ * @param {*} payload - Input expected to match ProofProposal.
+ * @returns {Buffer} Encoded or an empty buffer.
+ */
+export const safeEncodeProofProposal = (payload) => {
+    try {
+        return encodeProofProposal(payload);
+    } catch (error) {
+        console.log("safeEncodeProofProposal error:", error.message);
+    }
+
+    return b4a.alloc(0);
+}
+
+/**
+ * Safely decodes a ProofProposal for apply-function validation paths.
+ * Returns null when the input is not a buffer or cannot be decoded.
+ *
+ * @param {*} payload - Encoded ProofProposal buffer.
+ * @returns {Object|null} Decoded or null.
+ */
+export const safeDecodeProofProposal = (payload) => {
+    try {
+        if (!b4a.isBuffer(payload)) return null;
+        return decodeProofProposal(payload);
+    } catch (error) {
+        console.log("safeDecodeProofProposal error:", error.message);
+    }
+    return null;
+}
+
+export const encodeEpochAppendIntent = payload => encodeMessage(EpochAppendIntent, payload);

package/src/codecs/consensus/v1/vdfConfigCodec.js

@@ -0,0 +1,83 @@
+import b4a from 'b4a';
+import _ from 'lodash';
+import {
+    VDF_DIFFICULTY_SIZE,
+    VDF_DISCRIMINANT_SIZE
+} from '../../../utils/constants.js';
+
+const VDF_CONFIG_SIZE = VDF_DIFFICULTY_SIZE + VDF_DISCRIMINANT_SIZE;
+
+/**
+ * Canonically encodes a VDF configuration.
+ *
+ * @param {{difficulty: Buffer, discriminantBitSize: Buffer}} config - VDF configuration.
+ * @returns {Buffer} The canonical encoded VDF configuration.
+ * @throws {Error} When the configuration is structurally invalid.
+ */
+export const encodeVdfConfig = (config) => {
+    if (!_.isPlainObject(config)) {
+        throw new Error('VDF config must be an object.');
+    }
+
+    if (!b4a.isBuffer(config.difficulty) || config.difficulty.length !== VDF_DIFFICULTY_SIZE) {
+        throw new Error(`VDF config difficulty must be a ${VDF_DIFFICULTY_SIZE}-byte buffer.`);
+    }
+
+    if (
+        !b4a.isBuffer(config.discriminantBitSize) ||
+        config.discriminantBitSize.length !== VDF_DISCRIMINANT_SIZE
+    ) {
+        throw new Error(
+            `VDF config discriminant bit size must be a ${VDF_DISCRIMINANT_SIZE}-byte buffer.`
+        );
+    }
+
+    return b4a.concat([config.difficulty, config.discriminantBitSize]);
+}
+
+/**
+ * Decodes a canonical VDF configuration.
+ *
+ * @param {Buffer} encoded - Canonical encoded VDF configuration.
+ * @returns {{difficulty: Buffer, discriminantBitSize: Buffer}} The decoded configuration.
+ * @throws {Error} When the encoded configuration is structurally invalid.
+ */
+export const decodeVdfConfig = (encoded) => {
+    if (!b4a.isBuffer(encoded) ||
+        encoded.length !== VDF_CONFIG_SIZE) {
+        throw new Error(`Encoded VDF config must be a buffer of exactly ${VDF_CONFIG_SIZE} bytes.`);
+    }
+
+    return {
+        difficulty: b4a.toBuffer(encoded.subarray(0, VDF_DIFFICULTY_SIZE)),
+        discriminantBitSize: b4a.toBuffer(encoded.subarray(VDF_DIFFICULTY_SIZE))
+    };
+}
+
+/**
+ * Safely encodes a VDF configuration.
+ *
+ * @param {*} config - Value expected to contain a VDF configuration.
+ * @returns {Buffer} The canonical encoded configuration, or an empty buffer on failure.
+ */
+export const safeEncodeVdfConfig = (config) => {
+    try {
+        return encodeVdfConfig(config);
+    } catch {
+        return b4a.alloc(0);
+    }
+}
+
+/**
+ * Safely decodes a canonical VDF configuration.
+ *
+ * @param {*} encoded - Value expected to contain an encoded VDF configuration.
+ * @returns {{difficulty: Buffer, discriminantBitSize: Buffer}|null} The decoded configuration, or null on failure.
+ */
+export const safeDecodeVdfConfig = (encoded) => {
+    try {
+        return decodeVdfConfig(encoded);
+    } catch {
+        return null;
+    }
+}