test(crypto-proposal): increase unit test coverage

packages/consensus/source/consensus.ts

@@ -622,7 +622,7 @@ export class Consensus implements Contracts.Consensus.Service {
 		const proposal = roundState.getProposal();
 		if (!roundState.hasProcessorResult() && proposal) {
 			try {
-				await proposal.deserializeData();
+				await proposal.deserializePayload();
 
 				if (!(await this.proposalProcessor.hasValidLockProof(proposal))) {
 					roundState.setProcessorResult(FAILED_PROCESSOR_RESULT);

packages/consensus/source/processors/proposal-processor.ts

@@ -127,7 +127,7 @@ export class ProposalProcessor extends AbstractProcessor implements Contracts.Co
 	async #hasValidSignature(proposal: Contracts.Crypto.Proposal): Promise<boolean> {
 		return this.consensusSignature.verify(
 			Buffer.from(proposal.signature, "hex"),
-			await this.proposalSerializer.serializeProposal(proposal.toSerializableData(), { includeSignature: false }),
+			await this.proposalSerializer.serializeProposalUnsigned(proposal.toSerializableData()),
 			Buffer.from(this.validatorSet.getValidator(proposal.validatorIndex).blsPublicKey, "hex"),
 		);
 	}

packages/consensus/source/round-state.ts

@@ -103,7 +103,7 @@ export class RoundState implements Contracts.Consensus.RoundState {
 
 	public getBlock(): Contracts.Crypto.Block {
 		if (this.#proposal && this.#proposal.isDataDeserialized) {
-			return this.#proposal.getData().block;
+			return this.#proposal.getPayload().block;
 		}
 
 		throw new Error("Block is not available, because proposal is not set or deserialized");
@@ -117,7 +117,7 @@ export class RoundState implements Contracts.Consensus.RoundState {
 			assert.defined(proposal);
 
 			const round = proposal.round;
-			const block = proposal.getData().block;
+			const block = proposal.getPayload().block;
 
 			const commit: Contracts.Crypto.CommitSerializable = {
 				block,

packages/contracts/source/contracts/crypto/block.ts

@@ -76,6 +76,7 @@ export interface BlockFactory {
 	fromBytes(buff: Buffer): Promise<Block>;
 	fromJson(json: BlockJson): Promise<Block>;
 	fromStorage(header: BlockHeaderStorageData, transactions: TransactionStorageData[]): Promise<Block>;
+	headerFromBytes(buff: Buffer): Promise<BlockHeader>;
 	headerFromStorage(header: BlockHeaderStorageData): Promise<BlockHeader>;
 }
 

packages/contracts/source/contracts/crypto/proposal.ts

@@ -2,62 +2,54 @@ import type { Block, BlockHeader } from "./block.js";
 import type { KeyPair } from "./identities.js";
 import type { AggregatedSignature } from "./signatures.js";
 
-type WithoutSignature<T> = Omit<T, "signature">;
-export type MakeProposalData = WithoutSignature<SerializableProposalData>;
-
-export interface ProposalData {
-	readonly blockHeader: BlockHeader;
-	readonly lockProof?: AggregatedSignature;
+export interface ProposalDataSerializableUnsigned {
 	readonly round: number;
-	readonly data: { serialized: string };
-	readonly validatorIndex: number;
 	readonly validRound?: number;
+	readonly payloadSerialized: string;
+	readonly validatorIndex: number;
+}
+
+export interface ProposalDataSerializable extends ProposalDataSerializableUnsigned {
 	readonly signature: string;
 }
 
-export interface SerializableProposalData {
-	readonly round: number;
-	readonly validRound?: number;
-	readonly data: { serialized: string };
-	readonly validatorIndex: number;
-	readonly signature?: string;
+export interface ProposalData extends ProposalDataSerializable {
+	readonly blockHeader: BlockHeader;
+	readonly lockProof?: AggregatedSignature;
 }
 
-export interface ProposedData {
+export type ProposedPayloadSerializable = {
 	readonly block: Block;
 	readonly lockProof?: AggregatedSignature;
+};
+
+export interface ProposedPayload extends ProposedPayloadSerializable {
 	readonly serialized: string;
 }
 
-export type ProposedBlockSerializable = Omit<ProposedData, "serialized">;
-
-export interface Proposal extends Omit<ProposalData, "data"> {
+export interface Proposal extends ProposalData {
 	isDataDeserialized: boolean;
 
 	readonly serialized: Buffer;
 
-	deserializeData(): Promise<void>;
-	getData(): ProposedData;
+	deserializePayload(): Promise<void>;
+	getPayload(): ProposedPayload;
 
-	toSerializableData(): SerializableProposalData;
+	toSerializableData(): ProposalDataSerializable;
 	toData(): ProposalData;
 	toString(): string;
 }
 
 export interface ProposalFactory {
-	makeProposal(data: MakeProposalData, keyPair: KeyPair): Promise<Proposal>;
+	makeProposal(data: ProposalDataSerializableUnsigned, keyPair: KeyPair): Promise<Proposal>;
 	makeProposalFromBytes(data: Buffer): Promise<Proposal>;
-	makeProposalFromData(data: ProposalData): Promise<Proposal>;
-	makeProposedDataFromBytes(data: Buffer): Promise<ProposedData>;
-}
-
-export interface SerializeProposalOptions {
-	includeSignature?: boolean;
+	makePayloadFromBytes(data: Buffer): Promise<ProposedPayload>;
 }
 
 export interface ProposalSerializer {
-	serializeProposal(proposal: SerializableProposalData, options: SerializeProposalOptions): Promise<Buffer>;
-	serializeProposed(proposedBlock: ProposedBlockSerializable): Promise<Buffer>;
+	serializeProposalUnsigned(proposal: ProposalDataSerializableUnsigned): Promise<Buffer>;
+	serializeProposal(proposal: ProposalDataSerializable): Promise<Buffer>;
+	serializePayload(payload: ProposedPayloadSerializable): Promise<Buffer>;
 	serializeLockProof(proof: AggregatedSignature): Promise<Buffer>;
 }
 

packages/crypto-block/source/factory.test.ts

@@ -29,7 +29,8 @@ describe<{
 	factory: BlockFactory;
 	txFactory: Contracts.Crypto.TransactionFactory;
 	serializer: Serializer;
-}>("Factory", ({ it, assert, beforeEach }) => {
+	validator: Contracts.Crypto.Validator;
+}>("Factory", ({ it, assert, beforeEach, spy }) => {
 	const blockDataOriginal = clone(blockData);
 	const blockDataWithTransactionsOriginal = clone(blockDataWithTransactions);
 	let blockDataClone: Utils.Mutable<Contracts.Crypto.BlockData>;
@@ -45,6 +46,7 @@ describe<{
 			context.app.get<Contracts.Crypto.Validator>(Identifiers.Cryptography.Validator).addSchema(schema);
 		}
 
+		context.validator = context.app.get<Contracts.Crypto.Validator>(Identifiers.Cryptography.Validator);
 		context.factory = context.app.resolve(BlockFactory);
 		context.serializer = context.app.resolve(Serializer);
 		context.txFactory = context.app.get<Contracts.Crypto.TransactionFactory>(
@@ -167,6 +169,27 @@ describe<{
 		);
 	});
 
+	it("#headerFromBytes - should create a block header from bytes", async ({ factory, validator }) => {
+		const spyValidate = spy(validator, "validate");
+
+		const blockHeader = await factory.headerFromBytes(Buffer.from(serialized, "hex"));
+
+		assertBlockData(assert, blockHeader, blockData);
+		assert.undefined(blockHeader.serialized);
+		assert.undefined(blockHeader.transactions);
+
+		const blockHeaderWithTransactions = await factory.headerFromBytes(
+			Buffer.from(serializedWithTransactions, "hex"),
+		);
+
+		assertBlockData(assert, blockHeaderWithTransactions, blockDataWithTransactions);
+		assert.undefined(blockHeaderWithTransactions.serialized);
+		assert.undefined(blockHeaderWithTransactions.transactions);
+
+		spyValidate.calledTimes(2);
+		spyValidate.calledWith("blockHeader");
+	});
+
 	it("#headerFromStorage - should create a block header from storage", async ({ factory }) => {
 		const blockHeaderFromStorage = await factory.headerFromStorage(blockHeaderStorage);
 

packages/crypto-block/source/factory.ts

@@ -30,7 +30,7 @@ export class BlockFactory implements Contracts.Crypto.BlockFactory {
 	): Promise<Contracts.Crypto.Block> {
 		const block: Contracts.Crypto.BlockHeader = { ...data, hash: await this.hashFactory.make(data) };
 
-		await this.#verify({ ...block, transactions });
+		await this.#verify("block", { ...block, transactions });
 
 		const serialized: Buffer = await this.serializer.serializeWithTransactions({ ...data, transactions });
 
@@ -70,6 +70,13 @@ export class BlockFactory implements Contracts.Crypto.BlockFactory {
 		});
 	}
 
+	public async headerFromBytes(serialized: Buffer): Promise<Contracts.Crypto.BlockHeader> {
+		const blockHeader = await this.deserializer.deserializeHeader(serialized);
+		await this.#verify("blockHeader", blockHeader);
+
+		return blockHeader;
+	}
+
 	public async headerFromStorage(
 		header: Contracts.Evm.BlockHeaderStorageData,
 	): Promise<Contracts.Crypto.BlockHeader> {
@@ -108,7 +115,7 @@ export class BlockFactory implements Contracts.Crypto.BlockFactory {
 	}
 
 	public async fromData(data: Contracts.Crypto.BlockData): Promise<Contracts.Crypto.Block> {
-		await this.#verify(data);
+		await this.#verify("block", data);
 
 		const transactions = await Promise.all(
 			data.transactions.map((tx) => this.transactionFactory.fromData(tx, false)),
@@ -125,21 +132,19 @@ export class BlockFactory implements Contracts.Crypto.BlockFactory {
 	async #fromSerialized(serialized: Buffer): Promise<Contracts.Crypto.Block> {
 		const deserialized = await this.deserializer.deserializeWithTransactions(serialized);
 
-		await this.#verify({ ...deserialized.data, transactions: deserialized.transactions });
+		await this.#verify("block", { ...deserialized.data, transactions: deserialized.transactions });
 
 		return new Block({
 			...deserialized,
 			serialized: serialized.toString("hex"),
 		});
 	}
 
-	async #verify(data: Contracts.Crypto.BlockData): Promise<void> {
-		const { error } = this.validator.validate("block", data);
+	async #verify(schema: string, data: Contracts.Crypto.BlockData | Contracts.Crypto.BlockHeader): Promise<void> {
+		const { error } = this.validator.validate(schema, data);
 
-		if (!error) {
-			return;
+		if (error) {
+			throw new BlockSchemaError(data.number, error);
 		}
-
-		throw new BlockSchemaError(data.number, error);
 	}
 }

packages/crypto-messages/package.json

@@ -37,7 +37,6 @@
 		"@mainsail/crypto-hash-bcrypto": "workspace:*",
 		"@mainsail/crypto-key-pair-bls12-381": "workspace:*",
 		"@mainsail/crypto-key-pair-ecdsa": "workspace:*",
-		"@mainsail/crypto-proposal": "workspace:*",
 		"@mainsail/crypto-signature-bls12-381": "workspace:*",
 		"@mainsail/crypto-signature-ecdsa": "workspace:*",
 		"@mainsail/crypto-transaction": "workspace:*",

packages/crypto-messages/source/schemas.test.ts

@@ -10,7 +10,6 @@ import cryptoJson from "../../core/bin/config/devnet/core/crypto.json";
 import { Application } from "@mainsail/kernel";
 import { describe } from "@mainsail/test-runner";
 import { prevoteData, prevoteDataNoBlock } from "../test/fixtures/index.js";
-import { makeKeywords as makeProposalKeywords } from "@mainsail/crypto-proposal/source/keywords.js";
 import { schemas } from "./schemas";
 
 describe<{
@@ -27,7 +26,6 @@ describe<{
 
 		for (const keyword of Object.values({
 			...makeBaseKeywords(context.app.get<Configuration>(Identifiers.Cryptography.Configuration)),
-			...makeProposalKeywords(context.app.get<Configuration>(Identifiers.Cryptography.Configuration)),
 		})) {
 			context.validator.addKeyword(keyword);
 		}

packages/crypto-messages/test/helpers/prepare-sandbox.ts

@@ -7,7 +7,6 @@ import { ServiceProvider as CoreCryptoConfig } from "@mainsail/crypto-config";
 import { ServiceProvider as CoreCryptoHashBcrypto } from "@mainsail/crypto-hash-bcrypto";
 import { ServiceProvider as CoreCryptoKeyPairBls } from "@mainsail/crypto-key-pair-bls12-381";
 import { ServiceProvider as CoreCryptoKeyPairEcdsa } from "@mainsail/crypto-key-pair-ecdsa";
-import { makeKeywords } from "@mainsail/crypto-proposal/source/keywords.js";
 import { ServiceProvider as CoreCryptoSignatureBls } from "@mainsail/crypto-signature-bls12-381";
 import { ServiceProvider as CoreCryptoSignatureEcdsa } from "@mainsail/crypto-signature-ecdsa";
 import { ServiceProvider as CoreCryptoTransaction } from "@mainsail/crypto-transaction";
@@ -53,10 +52,6 @@ export const prepareSandbox = async (context: { app?: Application }): Promise<vo
 	context.app.bind(Identifiers.Cryptography.Message.Deserializer).to(Deserializer);
 	context.app.bind(Identifiers.Cryptography.Message.Factory).to(Factory).inSingletonScope();
 
-	for (const keyword of Object.values(makeKeywords(context.app.get(Identifiers.Cryptography.Configuration)))) {
-		context.app.get<Contracts.Crypto.Validator>(Identifiers.Cryptography.Validator).addKeyword(keyword);
-	}
-
 	for (const schema of Object.values(schemas)) {
 		context.app.get<Contracts.Crypto.Validator>(Identifiers.Cryptography.Validator).addSchema(schema);
 	}

packages/crypto-proposal/package.json

@@ -16,8 +16,10 @@
 		"release": "pnpm publish --access public",
 		"test": "pnpm run uvu source .test.ts",
 		"test:coverage": "c8 -r=text -r=lcov --all pnpm run test",
+		"test:coverage:file": "c8 -r=text -r=lcov --all pnpm run test:file",
 		"test:coverage:html": "c8 -r html --all pnpm run test",
 		"test:file": "pnpm run uvu source",
+		"test:fixtures": "tsx --tsconfig ../../tsconfig.test.json ./test/helpers/generate-fixtures.ts",
 		"uvu": "tsx --tsconfig ../../tsconfig.test.json ./node_modules/uvu/bin.js"
 	},
 	"dependencies": {

packages/crypto-proposal/source/deserializer.test.ts

@@ -1,10 +1,12 @@
 import { Application } from "@mainsail/kernel";
 import { describe } from "@mainsail/test-runner";
 import {
-	proposalData,
-	proposalDataWithValidRound,
-	serializedProposal,
-	serializedProposalDataWithValidRound,
+	Proposal,
+	ProposalWithValidRound,
+	ProposalWithLockProof,
+	ProposalWithLockProofAndValidRound,
+	lockProof,
+	serializedLockProof,
 } from "../test/fixtures/index.js";
 import { assertProposal } from "../test/helpers/asserts";
 import { prepareSandbox } from "../test/helpers/prepare-sandbox";
@@ -21,14 +23,19 @@ describe<{
 	});
 
 	it("#deserializeProposal - should correctly deserialize", async ({ deserializer }) => {
-		const deserialized = await deserializer.deserializeProposal(Buffer.from(serializedProposal, "hex"));
-		assertProposal(assert, deserialized, proposalData);
+		for (const { proposalSerialized, proposalData } of [
+			Proposal,
+			ProposalWithValidRound,
+			ProposalWithLockProof,
+			ProposalWithLockProofAndValidRound,
+		]) {
+			const deserialized = await deserializer.deserializeProposal(Buffer.from(proposalSerialized, "hex"));
+			assertProposal(assert, deserialized, proposalData);
+		}
 	});
 
-	it("#deserializeProposal - should correctly deserialize, with validRound", async ({ deserializer }) => {
-		const deserialized = await deserializer.deserializeProposal(
-			Buffer.from(serializedProposalDataWithValidRound, "hex"),
-		);
-		assertProposal(assert, deserialized, proposalDataWithValidRound);
+	it("#deserializeLockProof - should correctly deserialize", async ({ deserializer }) => {
+		const deserialized = await deserializer.deserializeLockProof(Buffer.from(serializedLockProof, "hex"));
+		assert.equal(deserialized, lockProof);
 	});
 });

packages/crypto-proposal/source/deserializer.ts

@@ -1,6 +1,7 @@
 import { Identifiers } from "@mainsail/constants";
 import { inject, injectable } from "@mainsail/container";
 import type { Contracts } from "@mainsail/contracts";
+import { InvalidProposalBytesError } from "@mainsail/exceptions";
 import { ByteBuffer } from "@mainsail/utils";
 
 import { lockProofSchema, schema } from "./serializer-schemas.js";
@@ -22,6 +23,10 @@ export class Deserializer implements Contracts.Crypto.ProposalDeserializer {
 			schema,
 		});
 
+		if (buffer.getRemainderLength() !== 0) {
+			throw new InvalidProposalBytesError(`Found trailing bytes of length ${buffer.getRemainderLength()}`);
+		}
+
 		return proposal;
 	}