POM Plugin contradicting header validation to the plugin (#8861)

* ♻️ Adds contradicting header validation to the plugin instead of invoking chain_areHeadersContradicting endpoint

* ♻️ ✅

* 🚚 ♻️ ✅ get_contradicting_block_header.spec.ts to db.spec.ts

---------

Co-authored-by: !shan <ishantiw.quasar@gmail.com>

examples/pos-mainchain/src/app/plugins.ts

@@ -1,4 +1,7 @@
 /* eslint-disable @typescript-eslint/no-empty-function */
+import { ReportMisbehaviorPlugin } from '@liskhq/lisk-framework-report-misbehavior-plugin';
 import { Application } from 'lisk-sdk';
 
-export const registerPlugins = (_app: Application): void => {};
+export const registerPlugins = (_app: Application): void => {
+	_app.registerPlugin(new ReportMisbehaviorPlugin());
+};

framework-plugins/lisk-framework-report-misbehavior-plugin/src/db.ts

@@ -15,7 +15,13 @@
 import * as os from 'os';
 import { join } from 'path';
 import { ensureDir } from 'fs-extra';
-import { cryptography, codec, chain, db as liskDB, BasePlugin } from 'lisk-sdk';
+import {
+	cryptography,
+	codec,
+	chain,
+	db as liskDB,
+	areDistinctHeadersContradicting,
+} from 'lisk-sdk';
 
 const { BlockHeader } = chain;
 const { utils } = cryptography;
@@ -94,9 +100,7 @@ type IteratableStream = NodeJS.ReadableStream & { destroy: (err?: Error) => void
 export const getContradictingBlockHeader = async (
 	db: liskDB.Database,
 	blockHeader: chain.BlockHeader,
-	apiClient: BasePlugin['apiClient'],
 ): Promise<chain.BlockHeader | undefined> => {
-	const header1 = blockHeader.getBytes().toString('hex');
 	const existingHeaders = await new Promise<string[]>((resolve, reject) => {
 		const stream = db.createReadStream({
 			gte: Buffer.concat([blockHeader.generatorAddress, Buffer.alloc(4, 0)]),
@@ -117,13 +121,18 @@ export const getContradictingBlockHeader = async (
 				resolve(results);
 			});
 	});
-	for (const header2 of existingHeaders) {
-		const { valid } = await apiClient.invoke<{ valid: boolean }>('chain_areHeadersContradicting', {
-			header1,
-			header2,
-		});
-		if (valid) {
-			return BlockHeader.fromBytes(Buffer.from(header2, 'hex'));
+
+	for (const headerString of existingHeaders) {
+		const header = BlockHeader.fromBytes(Buffer.from(headerString, 'hex'));
+
+		if (blockHeader.id.equals(header.id)) {
+			continue;
+		}
+
+		const isContradicting = areDistinctHeadersContradicting(header, blockHeader);
+
+		if (isContradicting) {
+			return header;
 		}
 	}
 	return undefined;

framework-plugins/lisk-framework-report-misbehavior-plugin/src/report_misbehavior_plugin.ts

@@ -100,7 +100,6 @@ export class ReportMisbehaviorPlugin extends BasePlugin<ReportMisbehaviorPluginC
 					const contradictingBlock = await getContradictingBlockHeader(
 						this._pluginDB,
 						decodedBlockHeader,
-						this.apiClient,
 					);
 					if (contradictingBlock && this._state.privateKey) {
 						const encodedTransaction = await this._createPoMTransaction(

framework-plugins/lisk-framework-report-misbehavior-plugin/test/integration/db.spec.ts

@@ -83,31 +83,19 @@ describe('db', () => {
 				),
 				id: Buffer.from('e734e77355e887660b5a8382eba26fa0b536b7deb1ddfdda394bdb6614b4cd55', 'hex'),
 			});
-			const result = await getContradictingBlockHeader(
-				db,
-				header,
-				reportMisbehaviorPlugin['apiClient'],
-			);
+			const result = await getContradictingBlockHeader(db, header);
 			expect(result).toBeUndefined();
 		});
 
 		it('should resolve undefine when there are no conflicting block header by the same generator', async () => {
 			const decodedBlockHeader1 = chain.BlockHeader.fromBytes(blockHeader1);
-			const result = await getContradictingBlockHeader(
-				db,
-				decodedBlockHeader1,
-				reportMisbehaviorPlugin['apiClient'],
-			);
+			const result = await getContradictingBlockHeader(db, decodedBlockHeader1);
 			expect(result).toBeUndefined();
 		});
 
 		it('should resolve a contradicting blockheader when there is a conflicting block in the database', async () => {
 			const decodedBlockHeader1 = chain.BlockHeader.fromBytes(blockHeader1Contradicting);
-			const result = await getContradictingBlockHeader(
-				db,
-				decodedBlockHeader1,
-				reportMisbehaviorPlugin['apiClient'],
-			);
+			const result = await getContradictingBlockHeader(db, decodedBlockHeader1);
 			expect(result).toBeDefined();
 
 			expect(result?.getBytes().toString('hex')).toEqual(blockHeader1.toString('hex'));

framework-plugins/lisk-framework-report-misbehavior-plugin/test/unit/db.spec.ts

@@ -0,0 +1,114 @@
+/*
+ * Copyright © 2023 Lisk Foundation
+ *
+ * See the LICENSE file at the top-level directory of this distribution
+ * for licensing information.
+ *
+ * Unless otherwise agreed in a custom licensing agreement with the Lisk Foundation,
+ * no part of this software, including this file, may be copied, modified,
+ * propagated, or distributed except according to the terms contained in the
+ * LICENSE file.
+ *
+ * Removal or modification of this copyright notice is prohibited.
+ */
+
+import { rmSync } from 'fs-extra';
+import * as sdk from 'lisk-sdk';
+import { chain, db as liskDB, blockHeaderSchema, codec, BlockHeader } from 'lisk-sdk';
+import { getContradictingBlockHeader, saveBlockHeaders } from '../../src/db';
+
+describe('db', () => {
+	const dbPath = 'test-lisk-framework-report-misbehavior-plugin.db';
+	const db = new liskDB.Database(dbPath);
+
+	const random20Bytes = Buffer.from('40ff452fae2affe6eeef3c30e53e9eac35a1bc43', 'hex');
+	const random32Bytes = Buffer.from(
+		'3d1b5dd1ef4ff7b22359598ebdf58966a51adcc03e02ad356632743e65898990',
+		'hex',
+	);
+	const header1 = new chain.BlockHeader({
+		height: 100,
+		aggregateCommit: {
+			aggregationBits: Buffer.alloc(0),
+			certificateSignature: Buffer.alloc(0),
+			height: 0,
+		},
+		impliesMaxPrevotes: false,
+		generatorAddress: random20Bytes,
+		maxHeightGenerated: 0,
+		maxHeightPrevoted: 50,
+		previousBlockID: random32Bytes,
+		timestamp: 100,
+		version: 2,
+		assetRoot: random32Bytes,
+		eventRoot: random32Bytes,
+		stateRoot: random32Bytes,
+		transactionRoot: random32Bytes,
+		validatorsHash: random32Bytes,
+		signature: random32Bytes,
+	});
+
+	const headerBytes1 = codec.encode(blockHeaderSchema, header1);
+
+	afterAll(async () => {
+		await db.clear();
+
+		db.close();
+
+		rmSync(dbPath, {
+			recursive: true,
+			force: true,
+		});
+	});
+
+	describe('getContradictingBlockHeader', () => {
+		const headerClone = BlockHeader.fromBytes(headerBytes1);
+
+		const header2 = new chain.BlockHeader({
+			id: Buffer.from('ff', 'hex'),
+			height: 100,
+			aggregateCommit: {
+				aggregationBits: Buffer.alloc(0),
+				certificateSignature: Buffer.alloc(0),
+				height: 0,
+			},
+			impliesMaxPrevotes: false,
+			generatorAddress: random20Bytes,
+			maxHeightGenerated: 0,
+			maxHeightPrevoted: 32,
+			previousBlockID: random32Bytes,
+			timestamp: 100,
+			version: 2,
+			assetRoot: random32Bytes,
+			eventRoot: random32Bytes,
+			stateRoot: random32Bytes,
+			transactionRoot: random32Bytes,
+			validatorsHash: random32Bytes,
+			signature: random32Bytes,
+		});
+
+		beforeEach(async () => {
+			await saveBlockHeaders(db, headerBytes1);
+		});
+
+		it('should return undefined if plugin database is empty', async () => {
+			await expect(getContradictingBlockHeader(db, headerClone)).resolves.toBeUndefined();
+		});
+
+		it('should return undefined if block headers have same id', async () => {
+			await expect(getContradictingBlockHeader(db, headerClone)).resolves.toBeUndefined();
+		});
+
+		it('should return undefined if block headers are not contradicting', async () => {
+			jest.spyOn(sdk, 'areDistinctHeadersContradicting').mockImplementation(() => false);
+
+			await expect(getContradictingBlockHeader(db, header2)).resolves.toBeUndefined();
+		});
+
+		it('should return the block in plugin db if blocks are contradicting', async () => {
+			jest.spyOn(sdk, 'areDistinctHeadersContradicting').mockImplementation(() => true);
+
+			await expect(getContradictingBlockHeader(db, header2)).resolves.toEqual(headerClone);
+		});
+	});
+});

framework/src/engine/bft/index.ts

@@ -14,5 +14,5 @@
 
 export { BFTModule } from './module';
 export type { BFTMethod } from './method';
-export { computeValidatorsHash } from './utils';
+export { computeValidatorsHash, areDistinctHeadersContradicting } from './utils';
 export { BFTParameters } from './schemas';

framework/src/engine/index.ts

@@ -13,4 +13,4 @@
  */
 
 export { Engine } from './engine';
-export { computeValidatorsHash, BFTParameters } from './bft';
+export { computeValidatorsHash, areDistinctHeadersContradicting, BFTParameters } from './bft';

framework/src/index.ts

@@ -182,3 +182,4 @@ export {
 	CHAIN_ID_LENGTH,
 } from './modules/interoperability/constants';
 export { Proof, QueryProof, ProveResponse, Validator as BFTValidator } from './abi/abi';
+export { areDistinctHeadersContradicting } from './engine/bft';