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/primitives/api/test/tests/decl_and_impl.rs

@@ -18,11 +18,9 @@
 use sp_api::{
 	decl_runtime_apis, impl_runtime_apis, mock_impl_runtime_apis, ApiError, ApiExt, RuntimeApiInfo,
 };
-use sp_runtime::{
-	generic::BlockId,
-	traits::{Block as BlockT, GetNodeBlockType},
-};
-use substrate_test_runtime_client::runtime::Block;
+use sp_runtime::traits::{Block as BlockT, GetNodeBlockType};
+
+use substrate_test_runtime_client::runtime::{Block, Hash};
 
 /// The declaration of the `Runtime` type and the implementation of the `GetNodeBlockType`
 /// trait are done by the `construct_runtime!` macro in a real runtime.
@@ -119,13 +117,13 @@ mock_impl_runtime_apis! {
 		}
 
 		#[advanced]
-		fn same_name(_: &BlockId<Block>) -> Result<(), ApiError> {
+		fn same_name(_: <Block as BlockT>::Hash) -> Result<(), ApiError> {
 			Ok(().into())
 		}
 
 		#[advanced]
-		fn wild_card(at: &BlockId<Block>, _: u32) -> Result<(), ApiError> {
-			if let BlockId::Number(1337) = at {
+		fn wild_card(at: <Block as BlockT>::Hash, _: u32) -> Result<(), ApiError> {
+			if Hash::repeat_byte(0x0f) == at {
 				// yeah
 				Ok(().into())
 			} else {
@@ -150,19 +148,19 @@ type TestClient = substrate_test_runtime_client::client::Client<
 fn test_client_side_function_signature() {
 	let _test: fn(
 		&RuntimeApiImpl<Block, TestClient>,
-		&BlockId<Block>,
+		<Block as BlockT>::Hash,
 		u64,
 	) -> Result<(), ApiError> = RuntimeApiImpl::<Block, TestClient>::test;
 	let _something_with_block: fn(
 		&RuntimeApiImpl<Block, TestClient>,
-		&BlockId<Block>,
+		<Block as BlockT>::Hash,
 		Block,
 	) -> Result<Block, ApiError> = RuntimeApiImpl::<Block, TestClient>::something_with_block;
 
 	#[allow(deprecated)]
 	let _same_name_before_version_2: fn(
 		&RuntimeApiImpl<Block, TestClient>,
-		&BlockId<Block>,
+		<Block as BlockT>::Hash,
 	) -> Result<String, ApiError> = RuntimeApiImpl::<Block, TestClient>::same_name_before_version_2;
 }
 
@@ -204,8 +202,8 @@ fn check_runtime_api_versions() {
 fn mock_runtime_api_has_api() {
 	let mock = MockApi { block: None };
 
-	assert!(mock.has_api::<dyn ApiWithCustomVersion<Block>>(&BlockId::Number(0)).unwrap());
-	assert!(mock.has_api::<dyn Api<Block>>(&BlockId::Number(0)).unwrap());
+	assert!(mock.has_api::<dyn ApiWithCustomVersion<Block>>(Hash::default()).unwrap());
+	assert!(mock.has_api::<dyn Api<Block>>(Hash::default()).unwrap());
 }
 
 #[test]
@@ -214,17 +212,17 @@ fn mock_runtime_api_panics_on_calling_old_version() {
 	let mock = MockApi { block: None };
 
 	#[allow(deprecated)]
-	let _ = mock.same_name_before_version_2(&BlockId::Number(0));
+	let _ = mock.same_name_before_version_2(Hash::default());
 }
 
 #[test]
 fn mock_runtime_api_works_with_advanced() {
 	let mock = MockApi { block: None };
 
-	Api::<Block>::same_name(&mock, &BlockId::Number(0)).unwrap();
-	mock.wild_card(&BlockId::Number(1337), 1).unwrap();
+	Api::<Block>::same_name(&mock, Hash::default()).unwrap();
+	mock.wild_card(Hash::repeat_byte(0x0f), 1).unwrap();
 	assert_eq!(
 		"Test error".to_string(),
-		mock.wild_card(&BlockId::Number(1336), 1).unwrap_err().to_string(),
+		mock.wild_card(Hash::repeat_byte(0x01), 1).unwrap_err().to_string(),
 	);
 }