BlockId removal: runtime-api refactor (#13255)

* BlockId removal: refactor of runtime API

It changes the arguments of:
- `ApiExt` methods:  `has_api`, `has_api_with`, `api_version`
- `CallApiAt` method: `runtime_version_at`
from: `BlockId<Block>` to: `Block::Hash`

It also changes the first argument of all generated runtime API calls from: `BlockId<Block>` to: `Block::Hash`

This PR is part of BlockId::Number refactoring analysis (paritytech/substrate#11292)

* BlockId removal: refactor of runtime API - tests

- tests adjusted to new runtime API,
- some tests migrated from block number to block hash

* benchmarking-cli: BlockId(0) migrated to info().genesis_hash

`runtime_api.call()` now requires the block hash instead of BlockId::Number.
To access the genesis hash widely used in benchmarking engine the Client
was constrained to satisfy `sp_blockchain::HeaderBackend<Block>` trait
which provides `info().genesis_hash`.

* trivial: api.call(BlockId) -> api.call(Hash)

- Migrated all `runtime_api.calls` to use Hash
- Noteworthy (?):
-- `validate_transaction_blocking` in transaction pool,

* CallApiAtParams::at changed to Block::Hash

* missed doc updated

* Apply suggestions from code review

Co-authored-by: Bastian Köcher <git@kchr.de>

* ".git/.scripts/commands/fmt/fmt.sh"

* BlockId removal: Benchmark::consumed_weight

Little refactor around `Benchmark::consumed_weight`: `BlockId` removed.

* at_hash renamed

* wrong merge fixed

* beefy worker: merged with master

* beefy: tests: missing block problem fixed

* Apply review suggestion

* fix

---------

Co-authored-by: Bastian Köcher <git@kchr.de>
Co-authored-by: command-bot <>

substrate/utils/frame/benchmarking-cli/src/block/bench.rs

@@ -92,13 +92,12 @@ where
 
 		for i in self.params.from..=self.params.to {
 			let block_num = BlockId::Number(i.into());
-			let parent_num = BlockId::Number(((i - 1) as u32).into());
-			let consumed = self.consumed_weight(&block_num)?;
 			let hash = self.client.expect_block_hash_from_id(&block_num)?;
+			let consumed = self.consumed_weight(hash)?;
 
 			let block = self.client.block(hash)?.ok_or(format!("Block {} not found", block_num))?;
 			let block = self.unsealed(block.block);
-			let took = self.measure_block(&block, &parent_num)?;
+			let took = self.measure_block(&block, *block.header().parent_hash())?;
 
 			self.log_weight(i, block.extrinsics().len(), consumed, took);
 		}
@@ -107,7 +106,7 @@ where
 	}
 
 	/// Return the average *execution* aka. *import* time of the block.
-	fn measure_block(&self, block: &Block, parent_num: &BlockId<Block>) -> Result<NanoSeconds> {
+	fn measure_block(&self, block: &Block, parent_hash: Block::Hash) -> Result<NanoSeconds> {
 		let mut record = Vec::<NanoSeconds>::default();
 		// Interesting part here:
 		// Execute the block multiple times and collect stats about its execution time.
@@ -117,7 +116,7 @@ where
 			let start = Instant::now();
 
 			runtime_api
-				.execute_block(&parent_num, block)
+				.execute_block(parent_hash, block)
 				.map_err(|e| Error::Client(RuntimeApiError(e)))?;
 
 			record.push(start.elapsed().as_nanos() as NanoSeconds);
@@ -131,7 +130,7 @@ where
 	///
 	/// This is the post-dispatch corrected weight and is only available
 	/// after executing the block.
-	fn consumed_weight(&self, block: &BlockId<Block>) -> Result<NanoSeconds> {
+	fn consumed_weight(&self, block_hash: Block::Hash) -> Result<NanoSeconds> {
 		// Hard-coded key for System::BlockWeight. It could also be passed in as argument
 		// for the benchmark, but I think this should work as well.
 		let hash = array_bytes::hex2bytes(
@@ -139,11 +138,10 @@ where
 		)?;
 		let key = StorageKey(hash);
 
-		let block_hash = self.client.expect_block_hash_from_id(block)?;
 		let mut raw_weight = &self
 			.client
 			.storage(block_hash, &key)?
-			.ok_or(format!("Could not find System::BlockWeight for block: {}", block))?
+			.ok_or(format!("Could not find System::BlockWeight for block: {}", block_hash))?
 			.0[..];
 
 		let weight = ConsumedWeight::decode_all(&mut raw_weight)?;

substrate/utils/frame/benchmarking-cli/src/extrinsic/bench.rs

@@ -20,13 +20,13 @@
 use sc_block_builder::{BlockBuilderApi, BlockBuilderProvider};
 use sc_cli::{Error, Result};
 use sc_client_api::Backend as ClientBackend;
-use sp_api::{ApiExt, BlockId, Core, ProvideRuntimeApi};
+use sp_api::{ApiExt, Core, ProvideRuntimeApi};
 use sp_blockchain::{
 	ApplyExtrinsicFailed::Validity,
 	Error::{ApplyExtrinsicFailed, RuntimeApiError},
 };
 use sp_runtime::{
-	traits::{Block as BlockT, Zero},
+	traits::Block as BlockT,
 	transaction_validity::{InvalidTransaction, TransactionValidityError},
 	Digest, DigestItem, OpaqueExtrinsic,
 };
@@ -73,7 +73,9 @@ impl<Block, BA, C> Benchmark<Block, BA, C>
 where
 	Block: BlockT<Extrinsic = OpaqueExtrinsic>,
 	BA: ClientBackend<Block>,
-	C: BlockBuilderProvider<BA, Block, C> + ProvideRuntimeApi<Block>,
+	C: BlockBuilderProvider<BA, Block, C>
+		+ ProvideRuntimeApi<Block>
+		+ sp_blockchain::HeaderBackend<Block>,
 	C::Api: ApiExt<Block, StateBackend = BA::State> + BlockBuilderApi<Block>,
 {
 	/// Create a new [`Self`] from the arguments.
@@ -167,13 +169,13 @@ where
 	/// Measures the time that it take to execute a block or an extrinsic.
 	fn measure_block(&self, block: &Block) -> Result<BenchRecord> {
 		let mut record = BenchRecord::new();
-		let genesis = BlockId::Number(Zero::zero());
+		let genesis = self.client.info().genesis_hash;
 
 		info!("Running {} warmups...", self.params.warmup);
 		for _ in 0..self.params.warmup {
 			self.client
 				.runtime_api()
-				.execute_block(&genesis, block.clone())
+				.execute_block(genesis, block.clone())
 				.map_err(|e| Error::Client(RuntimeApiError(e)))?;
 		}
 
@@ -186,7 +188,7 @@ where
 			let start = Instant::now();
 
 			runtime_api
-				.execute_block(&genesis, block)
+				.execute_block(genesis, block)
 				.map_err(|e| Error::Client(RuntimeApiError(e)))?;
 
 			let elapsed = start.elapsed().as_nanos();

substrate/utils/frame/benchmarking-cli/src/extrinsic/cmd.rs

@@ -94,7 +94,9 @@ impl ExtrinsicCmd {
 	where
 		Block: BlockT<Extrinsic = OpaqueExtrinsic>,
 		BA: ClientBackend<Block>,
-		C: BlockBuilderProvider<BA, Block, C> + ProvideRuntimeApi<Block>,
+		C: BlockBuilderProvider<BA, Block, C>
+			+ ProvideRuntimeApi<Block>
+			+ sp_blockchain::HeaderBackend<Block>,
 		C::Api: ApiExt<Block, StateBackend = BA::State> + BlockBuilderApi<Block>,
 	{
 		// Short circuit if --list was specified.

substrate/utils/frame/benchmarking-cli/src/overhead/cmd.rs

@@ -108,7 +108,9 @@ impl OverheadCmd {
 	where
 		Block: BlockT<Extrinsic = OpaqueExtrinsic>,
 		BA: ClientBackend<Block>,
-		C: BlockBuilderProvider<BA, Block, C> + ProvideRuntimeApi<Block>,
+		C: BlockBuilderProvider<BA, Block, C>
+			+ ProvideRuntimeApi<Block>
+			+ sp_blockchain::HeaderBackend<Block>,
 		C::Api: ApiExt<Block, StateBackend = BA::State> + BlockBuilderApi<Block>,
 	{
 		if ext_builder.pallet() != "system" || ext_builder.extrinsic() != "remark" {