feat: Add finalized tag when querying blocks (Tests included)

src/controllers/blocks/BlocksController.ts

@@ -1,4 +1,5 @@
 import { ApiPromise } from '@polkadot/api';
+import { isHex } from '@polkadot/util';
 import { RequestHandler } from 'express';
 
 import { BlocksService } from '../../services';
@@ -94,14 +95,26 @@ export default class BlocksController extends AbstractController<BlocksService>
 		const eventDocsArg = eventDocs === 'true';
 		const extrsinsicDocsArg = extrinsicDocs === 'true';
 
-		const hash =
-			finalized === 'false' || !this.options.finalizes
-				? (await this.api.rpc.chain.getHeader()).hash
-				: await this.api.rpc.chain.getFinalizedHead();
+		let hash;
+		let queryFinalizedHead;
+
+		if (finalized === 'false' || !this.options.finalizes) {
+			queryFinalizedHead = true;
+			hash = (await this.api.rpc.chain.getHeader()).hash;
+		} else {
+			queryFinalizedHead = false;
+			hash = await this.api.rpc.chain.getFinalizedHead();
+		}
 
 		BlocksController.sanitizedSend(
 			res,
-			await this.service.fetchBlock(hash, eventDocsArg, extrsinsicDocsArg)
+			await this.service.fetchBlock(
+				hash,
+				eventDocsArg,
+				extrsinsicDocsArg,
+				finalized === 'false' ? false : true,
+				queryFinalizedHead
+			)
 		);
 	};
 
@@ -115,17 +128,22 @@ export default class BlocksController extends AbstractController<BlocksService>
 		{ params: { number }, query: { eventDocs, extrinsicDocs } },
 		res
 	): Promise<void> => {
+		const checkFinalized = isHex(number) && number.length === 66;
+
 		const hash = await this.getHashForBlock(number);
 
 		const eventDocsArg = eventDocs === 'true';
 		const extrinsinsicDocsArg = extrinsicDocs === 'true';
 
+		// Add Check finalized boolean
 		BlocksController.sanitizedSend(
 			res,
 			await this.service.fetchBlock(
 				hash,
 				eventDocsArg,
-				extrinsinsicDocsArg
+				extrinsinsicDocsArg,
+				checkFinalized,
+				true // We set to true because we havent queried the finalizedHead
 			)
 		);
 	};

src/services/blocks/BlocksService.spec.ts

@@ -1,4 +1,5 @@
 /* eslint-disable @typescript-eslint/no-unsafe-call */
+import { ApiPromise } from '@polkadot/api';
 import { RpcPromiseResult } from '@polkadot/api/types/rpc';
 import { GenericExtrinsic } from '@polkadot/types';
 import { GenericCall } from '@polkadot/types/generic';
@@ -15,6 +16,7 @@ import {
 	getBlock,
 	mockApi,
 	mockBlock789629,
+	mockForkedBlock789629,
 } from '../test-helpers/mock';
 import * as block789629 from '../test-helpers/mock/data/block789629.json';
 import * as blocks789629Response from '../test-helpers/responses/blocks/blocks789629.json';
@@ -37,7 +39,13 @@ describe('BlocksService', () => {
 		it('works when ApiPromise works (block 789629)', async () => {
 			expect(
 				sanitizeNumbers(
-					await blocksService.fetchBlock(blockHash789629, true, true)
+					await blocksService.fetchBlock(
+						blockHash789629,
+						true,
+						true,
+						false,
+						false
+					)
 				)
 			).toMatchObject(blocks789629Response);
 		});
@@ -61,7 +69,13 @@ describe('BlocksService', () => {
 				}) as unknown) as GetBlock;
 
 			await expect(
-				blocksService.fetchBlock(blockHash789629, false, false)
+				blocksService.fetchBlock(
+					blockHash789629,
+					false,
+					false,
+					false,
+					false
+				)
 			).rejects.toThrow(
 				new Error(
 					`Cannot destructure property 'method' of 'extrinsic' as it is undefined.`
@@ -262,4 +276,80 @@ describe('BlocksService', () => {
 			);
 		});
 	});
+
+	describe('BlockService.isFinalizedBlock', () => {
+		it('Returns false when queried blockId is on a fork', async () => {
+			const getHeader = (_hash: Hash) =>
+				Promise.resolve().then(() => mockForkedBlock789629.header);
+
+			const getBlockHash = (_zero: number) =>
+				Promise.resolve().then(() =>
+					polkadotRegistry.createType(
+						'BlockHash',
+						'0x91b171bb158e2d3848fa23a9f1c25182fb8e20313b2c1eb49219da7a70ce90c3'
+					)
+				);
+
+			const forkMockApi = {
+				rpc: {
+					chain: {
+						getHeader,
+						getBlockHash,
+					},
+				},
+			} as ApiPromise;
+
+			const queriedHash = polkadotRegistry.createType(
+				'BlockHash',
+				'0x7b713de604a99857f6c25eacc115a4f28d2611a23d9ddff99ab0e4f1c17a8578'
+			);
+
+			const blockNumber = polkadotRegistry.createType(
+				'Compact<BlockNumber>',
+				789629
+			);
+
+			const finalizedHead = polkadotRegistry.createType(
+				'BlockHash',
+				'0x91b171bb158e2d3848fa23a9f1c25182fb8e20313b2c1eb49219da7a70ce90c3'
+			);
+
+			expect(
+				await blocksService['isFinalizedBlock'](
+					forkMockApi,
+					blockNumber,
+					queriedHash,
+					finalizedHead,
+					true
+				)
+			).toEqual(false);
+		});
+
+		it('Returns true when queried blockId is not on a fork', async () => {
+			const queriedHash = polkadotRegistry.createType(
+				'BlockHash',
+				'0x91b171bb158e2d3848fa23a9f1c25182fb8e20313b2c1eb49219da7a70ce90c3'
+			);
+
+			const blockNumber = polkadotRegistry.createType(
+				'Compact<BlockNumber>',
+				789629
+			);
+
+			const finalizedHead = polkadotRegistry.createType(
+				'BlockHash',
+				'0x91b171bb158e2d3848fa23a9f1c25182fb8e20313b2c1eb49219da7a70ce90c3'
+			);
+
+			expect(
+				await blocksService['isFinalizedBlock'](
+					mockApi,
+					blockNumber,
+					queriedHash,
+					finalizedHead,
+					true
+				)
+			).toEqual(true);
+		});
+	});
 });

src/services/blocks/BlocksService.ts

@@ -1,10 +1,11 @@
 import { ApiPromise } from '@polkadot/api';
 import { SignedBlockExtended } from '@polkadot/api-derive/type';
-import { GenericCall, Struct } from '@polkadot/types';
+import { Compact, GenericCall, Struct } from '@polkadot/types';
 import { AbstractInt } from '@polkadot/types/codec/AbstractInt';
 import {
 	Block,
 	BlockHash,
+	BlockNumber,
 	DispatchInfo,
 	EventRecord,
 	Hash,
@@ -37,29 +38,41 @@ export class BlocksService extends AbstractService {
 	 * Fetch a block enhanced with augmented and derived values.
 	 *
 	 * @param hash `BlockHash` of the block to fetch.
+	 * @param checkFinalized boolean to help reduce rpc calls in isFinalized
+	 * @param queryFinalizedHead boolean to help reduce rpc calls in fetchBlock
 	 */
 	async fetchBlock(
 		hash: BlockHash,
 		eventDocs: boolean,
-		extrinsicDocs: boolean
+		extrinsicDocs: boolean,
+		checkFinalized: boolean,
+		queryFinalizedHead: boolean
 	): Promise<IBlock> {
 		const { api } = this;
 
 		let block;
 		let events;
 		let author;
+		let finalizedHead;
+
 		if (typeof api.query.session?.validators?.at === 'function') {
 			// `api.derive.chain.getBlock` requires that `api.query.session?.validators?.at`
 			// is a function in order to query the validator set to pull out the author
 			// see: https://github.com/polkadot-js/api/blob/master/packages/api-derive/src/chain/getBlock.ts#L31
-			[{ author, block }, events] = await Promise.all([
+			[{ author, block }, events, finalizedHead] = await Promise.all([
 				api.derive.chain.getBlock(hash) as Promise<SignedBlockExtended>,
 				this.fetchEvents(api, hash),
+				queryFinalizedHead
+					? api.rpc.chain.getFinalizedHead()
+					: Promise.resolve(hash),
 			]);
 		} else {
-			[{ block }, events] = await Promise.all([
+			[{ block }, events, finalizedHead] = await Promise.all([
 				api.rpc.chain.getBlock(hash),
 				this.fetchEvents(api, hash),
+				queryFinalizedHead
+					? api.rpc.chain.getFinalizedHead()
+					: Promise.resolve(hash),
 			]);
 		}
 		const authorId = author;
@@ -91,6 +104,15 @@ export class BlocksService extends AbstractService {
 			eventDocs
 		);
 
+		// Check if the requested block is finalized
+		const finalized = await this.isFinalizedBlock(
+			api,
+			number,
+			hash,
+			finalizedHead,
+			checkFinalized
+		);
+
 		// The genesis block is a special case with little information associated with it.
 		if (parentHash.every((byte) => !byte)) {
 			return {
@@ -104,6 +126,7 @@ export class BlocksService extends AbstractService {
 				onInitialize,
 				extrinsics,
 				onFinalize,
+				finalized,
 			};
 		}
 
@@ -197,6 +220,7 @@ export class BlocksService extends AbstractService {
 			onInitialize,
 			extrinsics,
 			onFinalize,
+			finalized,
 		};
 	}
 
@@ -513,4 +537,72 @@ export class BlocksService extends AbstractService {
 			args: newArgs,
 		};
 	}
+
+	/**
+	 * When querying a block this will immediately inform the request whether
+	 * or not the queired block is considered finalized at the time of querying
+	 *
+	 * @param api ApiPromise to use for query
+	 * @param blockNumber Queried Block Number
+	 * @param queriedHash This is the Queried Hash param
+	 * @param finalizedHead This is the finalized head for our chain
+	 * @param checkFinalized If the passed in blockId is a hash we check query canonHash
+	 */
+	private async isFinalizedBlock(
+		api: ApiPromise,
+		blockNumber: Compact<BlockNumber>,
+		queriedHash: BlockHash,
+		finalizedHead: BlockHash,
+		checkFinalized: boolean
+	): Promise<boolean> {
+		/**
+		 * If the blockId is a hash it will run this first conditional.
+		 * If the blockId is not a hash, it is a block height, and will
+		 * run the else conditional
+		 */
+		if (checkFinalized) {
+			const [finalizedHeadBlock, canonHash] = await Promise.all([
+				// Returns a Finalized head Object
+				api.rpc.chain.getHeader(finalizedHead),
+				// We re-query the block via RPC to make sure that both our hash and
+				// canonHash match. Because when we query by blockNumber it will
+				// retrieve the block from the Canonical chain, and we can compare it
+				// to the original hash which is passed via the request params.
+				api.rpc.chain.getBlockHash(blockNumber.unwrap()),
+			]);
+
+			// If queried by hash this is the original request param
+			const hash = queriedHash.toHex();
+
+			// If this conditional is satisfied, the queried hash is on a fork,
+			// and is not on the canonical chain and therefore not finalized
+			if (canonHash.toHex() !== hash) {
+				return false;
+			}
+
+			// Retreive the finalized head blockNumber
+			const finalizedHeadBlockNumber = finalizedHeadBlock?.number;
+
+			// If the finalized head blockNumber is undefined return false
+			if (!finalizedHeadBlockNumber) {
+				return false;
+			}
+
+			// Check if the finalized head blockNumber is greater than the
+			// blockNumber in the request. If so the requested block is finalized.
+			return blockNumber.unwrap().lte(finalizedHeadBlockNumber.unwrap());
+		} else {
+			// Returns a Finalized head Object
+			const finalizedHeadBlock = await api.rpc.chain.getHeader(
+				finalizedHead
+			);
+
+			// Retreive the finalized head blockNumber
+			const finalizedHeadBlockNumber = finalizedHeadBlock?.number;
+
+			// Check if the finalized head blockNumber is greater than the
+			// blockNumber in the request. If so the requested block is finalized.
+			return blockNumber.unwrap().lte(finalizedHeadBlockNumber.unwrap());
+		}
+	}
 }

src/services/test-helpers/mock/data/blocks789629Fork.json

@@ -0,0 +1,32 @@
+{
+    "header": {
+        "hash": "0x91b171bb158e2d3848fa23a9f1c25182fb8e20313b2c1eb49219da7a70ce90c3",
+        "parentHash": "0xfbbdd075ab413168a83dbb7108f4e75516979b0acf40e691bbdcb5706f419be6",
+        "number": 789629,
+        "stateRoot": "0x2ff5d2e2e90ea7af2aca2c25ec1f79643bae368cf7e0fc1cd4414ff31cf39d19",
+        "extrinsicsRoot": "0x4c1d65bf6b57086f00d5df40aa0686ffbc581ef60878645613b1fc3303de5030",
+        "digest": {
+            "logs": [
+                {
+                    "PreRuntime": [
+                        1161969986,
+                        "0x036d000000f4f4d80f00000000ec9bd8e2d0368c97f3d888837f7283bbe08266869eb613159db547905026c2502a70f168b9ffcc233344005d11ebecd166769200d270a2eaa642118a00acb708a0487a440b0caf3dd5c91ab173e80ddfe5735ef8b938ea87a6105a1161612707"
+                    ]
+                },
+                {
+                    "Seal": [
+                        1161969986,
+                        "0xae78514e1de84a7d32e55b9b652f9d408ab1f7b4bfdbf6b2fad9cad94a91b86b0161cabf08f5ae1d3a1aa4993e2d96d56c94b03cee0898ccb8385a546084f88b"
+                    ]
+                }
+            ]
+        }
+    },
+    "extrinsics": [
+        "0x280403000bc016ed6c7301",
+        "0x1c040a00ea313000",
+        "0x1004140000",
+        "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",
+        "0x510884122efdea02dda2a9b56b20809ae8108ab89c5a8692e6197d0cc8cf4903a7e81601005267278172d49fde8a23513165bcd894ba0d9b5a7ee3e2976b5202d9f2a942515021b2c175ea46139b066709dfe610ec96d019b9622f7a46ee8f2587378b8a550304001d00a569f6e4cf6bed95cafbf001e13254b28710220cd9b208c10f7154c17740099f001100305c5062779d44ea2ab0469e155b8cf3e004fce71b3b3d38263cd9fa9478f12f28f1fe9f7ba0feab9e47684d4006ed25ad6c441a1553cef62748545ea575392af5a69484f2b10ec2f1dea19394423d576f91c6b5ab2315b389f4e108bcf0aa28408e29df67564eddc299a2aa1cdacbec3c1ae061cf0835c87e5b46b920f7573a774adf51a47b72795366d52285e329229c836ea7bbfe139dbe8fa0700c4f86fc563c82ab06b794c99f14a161973be7aa6012568b1c491d45ec969ed7420bcfaa59ca5bc1915da74aba3aadd7ce7b809045d5eb5b73559259755fdcd85a40a5dc6e6af08f6bb841825b168ddf79837e70d88d75e1c5b290b74fa97cedfd668dd22c984e16482c99cfad1436111e321a86d87d0fac203bf64538f888e45d793b54133235f7d984058bb410c163fc1d7a90e5475c0917aad77deb241093a50b4f683f3ef37fce11457ebc5f00b154996471fcd30eae17efe69e5a39b12b76034dc7e4a6996ba5fce10b5419b5a9fd55998b5d7fde4922e61f93b021cb2cf6dfd5707e0f00001a93fa350e"
+    ]
+}