Dependency (Substrate/Polkadot/Frontier/Cumulus/...) update to v0.9.40

benchmarking/frame-weight-template.hbs

@@ -14,30 +14,30 @@
 // You should have received a copy of the GNU General Public License
 // along with Moonbeam.  If not, see <http://www.gnu.org/licenses/>.
 
+{{header}}
 //! Autogenerated weights for {{pallet}}
 //!
 //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION {{version}}
-//! DATE: {{date}}, STEPS: `{{cmd.steps}}`, REPEAT: {{cmd.repeat}}, LOW RANGE: `{{cmd.lowest_range_values}}`, HIGH RANGE: `{{cmd.highest_range_values}}`
+//! DATE: {{date}}, STEPS: `{{cmd.steps}}`, REPEAT: `{{cmd.repeat}}`, LOW RANGE: `{{cmd.lowest_range_values}}`, HIGH RANGE: `{{cmd.highest_range_values}}`
+//! WORST CASE MAP SIZE: `{{cmd.worst_case_map_values}}`
+//! HOSTNAME: `{{hostname}}`, CPU: `{{cpuname}}`
 //! EXECUTION: {{cmd.execution}}, WASM-EXECUTION: {{cmd.wasm_execution}}, CHAIN: {{cmd.chain}}, DB CACHE: {{cmd.db_cache}}
 
 // Executed Command:
-{{#each args as |arg|~}}
+{{#each args as |arg|}}
 // {{arg}}
 {{/each}}
 
+#![cfg_attr(rustfmt, rustfmt_skip)]
 #![allow(unused_parens)]
 #![allow(unused_imports)]
 
-use frame_support::{
-	traits::Get,
-	weights::{constants::RocksDbWeight, Weight},
-};
+use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
 use sp_std::marker::PhantomData;
 
 /// Weight functions needed for {{pallet}}.
 pub trait WeightInfo {
 	{{#each benchmarks as |benchmark|}}
-	#[rustfmt::skip]
 	fn {{benchmark.name~}}
 	(
 		{{~#each benchmark.components as |c| ~}}
@@ -48,33 +48,46 @@ pub trait WeightInfo {
 
 /// Weights for {{pallet}} using the Substrate node and recommended hardware.
 pub struct SubstrateWeight<T>(PhantomData<T>);
+{{#if (eq pallet "frame_system")}}
+impl<T: crate::Config> WeightInfo for SubstrateWeight<T> {
+{{else}}
 impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
+{{/if}}
 	{{#each benchmarks as |benchmark|}}
 	{{#each benchmark.comments as |comment|}}
-	// {{comment}}
+	/// {{comment}}
+	{{/each}}
+	{{#each benchmark.component_ranges as |range|}}
+	/// The range of component `{{range.name}}` is `[{{range.min}}, {{range.max}}]`.
 	{{/each}}
-	#[rustfmt::skip]
 	fn {{benchmark.name~}}
 	(
 		{{~#each benchmark.components as |c| ~}}
 		{{~#if (not c.is_used)}}_{{/if}}{{c.name}}: u32, {{/each~}}
 	) -> Weight {
-		Weight::from_ref_time({{underscore benchmark.base_weight}} as u64)
+		// Proof Size summary in bytes:
+		//  Measured:  `{{benchmark.base_recorded_proof_size}}{{#each benchmark.component_recorded_proof_size as |cp|}} + {{cp.name}} * ({{cp.slope}} ±{{underscore cp.error}}){{/each}}`
+		//  Estimated: `{{benchmark.base_calculated_proof_size}}{{#each benchmark.component_calculated_proof_size as |cp|}} + {{cp.name}} * ({{cp.slope}} ±{{underscore cp.error}}){{/each}}`
+		// Minimum execution time: {{underscore benchmark.min_execution_time}}_000 picoseconds.
+		Weight::from_parts({{underscore benchmark.base_weight}}, {{benchmark.base_calculated_proof_size}})
 			{{#each benchmark.component_weight as |cw|}}
 			// Standard Error: {{underscore cw.error}}
-			.saturating_add(Weight::from_ref_time({{underscore cw.slope}} as u64).saturating_mul({{cw.name}} as u64))
+			.saturating_add(Weight::from_parts({{underscore cw.slope}}, 0).saturating_mul({{cw.name}}.into()))
 			{{/each}}
 			{{#if (ne benchmark.base_reads "0")}}
-			.saturating_add(T::DbWeight::get().reads({{benchmark.base_reads}} as u64))
+			.saturating_add(T::DbWeight::get().reads({{benchmark.base_reads}}_u64))
 			{{/if}}
 			{{#each benchmark.component_reads as |cr|}}
-			.saturating_add(T::DbWeight::get().reads(({{cr.slope}} as u64).saturating_mul({{cr.name}} as u64)))
+			.saturating_add(T::DbWeight::get().reads(({{cr.slope}}_u64).saturating_mul({{cr.name}}.into())))
 			{{/each}}
 			{{#if (ne benchmark.base_writes "0")}}
-			.saturating_add(T::DbWeight::get().writes({{benchmark.base_writes}} as u64))
+			.saturating_add(T::DbWeight::get().writes({{benchmark.base_writes}}_u64))
 			{{/if}}
 			{{#each benchmark.component_writes as |cw|}}
-			.saturating_add(T::DbWeight::get().writes(({{cw.slope}} as u64).saturating_mul({{cw.name}} as u64)))
+			.saturating_add(T::DbWeight::get().writes(({{cw.slope}}_u64).saturating_mul({{cw.name}}.into())))
+			{{/each}}
+			{{#each benchmark.component_calculated_proof_size as |cp|}}
+			.saturating_add(Weight::from_parts(0, {{cp.slope}}).saturating_mul({{cp.name}}.into()))
 			{{/each}}
 	}
 	{{/each}}
@@ -84,31 +97,40 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 impl WeightInfo for () {
 	{{#each benchmarks as |benchmark|}}
 	{{#each benchmark.comments as |comment|}}
-	// {{comment}}
+	/// {{comment}}
+	{{/each}}
+	{{#each benchmark.component_ranges as |range|}}
+	/// The range of component `{{range.name}}` is `[{{range.min}}, {{range.max}}]`.
 	{{/each}}
-	#[rustfmt::skip]
 	fn {{benchmark.name~}}
 	(
 		{{~#each benchmark.components as |c| ~}}
 		{{~#if (not c.is_used)}}_{{/if}}{{c.name}}: u32, {{/each~}}
 	) -> Weight {
-		Weight::from_ref_time({{underscore benchmark.base_weight}} as u64)
+		// Proof Size summary in bytes:
+		//  Measured:  `{{benchmark.base_recorded_proof_size}}{{#each benchmark.component_recorded_proof_size as |cp|}} + {{cp.name}} * ({{cp.slope}} ±{{underscore cp.error}}){{/each}}`
+		//  Estimated: `{{benchmark.base_calculated_proof_size}}{{#each benchmark.component_calculated_proof_size as |cp|}} + {{cp.name}} * ({{cp.slope}} ±{{underscore cp.error}}){{/each}}`
+		// Minimum execution time: {{underscore benchmark.min_execution_time}}_000 picoseconds.
+		Weight::from_parts({{underscore benchmark.base_weight}}, {{benchmark.base_calculated_proof_size}})
 			{{#each benchmark.component_weight as |cw|}}
 			// Standard Error: {{underscore cw.error}}
-			.saturating_add(Weight::from_ref_time({{underscore cw.slope}} as u64).saturating_mul({{cw.name}} as u64))
+			.saturating_add(Weight::from_parts({{underscore cw.slope}}, 0).saturating_mul({{cw.name}}.into()))
 			{{/each}}
 			{{#if (ne benchmark.base_reads "0")}}
-			.saturating_add(RocksDbWeight::get().reads({{benchmark.base_reads}} as u64))
+			.saturating_add(RocksDbWeight::get().reads({{benchmark.base_reads}}_u64))
 			{{/if}}
 			{{#each benchmark.component_reads as |cr|}}
-			.saturating_add(RocksDbWeight::get().reads(({{cr.slope}} as u64).saturating_mul({{cr.name}} as u64)))
+			.saturating_add(RocksDbWeight::get().reads(({{cr.slope}}_u64).saturating_mul({{cr.name}}.into())))
 			{{/each}}
 			{{#if (ne benchmark.base_writes "0")}}
-			.saturating_add(RocksDbWeight::get().writes({{benchmark.base_writes}} as u64))
+			.saturating_add(RocksDbWeight::get().writes({{benchmark.base_writes}}_u64))
 			{{/if}}
 			{{#each benchmark.component_writes as |cw|}}
-			.saturating_add(RocksDbWeight::get().writes(({{cw.slope}} as u64).saturating_mul({{cw.name}} as u64)))
+			.saturating_add(RocksDbWeight::get().writes(({{cw.slope}}_u64).saturating_mul({{cw.name}}.into())))
+			{{/each}}
+			{{#each benchmark.component_calculated_proof_size as |cp|}}
+			.saturating_add(Weight::from_parts(0, {{cp.slope}}).saturating_mul({{cp.name}}.into()))
 			{{/each}}
 	}
 	{{/each}}
-}
+}

client/rpc/debug/src/lib.rs

@@ -13,7 +13,7 @@
 
 // You should have received a copy of the GNU General Public License
 // along with Moonbeam.  If not, see <http://www.gnu.org/licenses/>.
-use futures::{SinkExt, StreamExt};
+use futures::StreamExt;
 use jsonrpsee::core::{async_trait, RpcResult};
 pub use moonbeam_rpc_core_debug::{DebugServer, TraceParams};
 
@@ -71,13 +71,12 @@ impl DebugServer for Debug {
 		transaction_hash: H256,
 		params: Option<TraceParams>,
 	) -> RpcResult<single::TransactionTrace> {
-		let mut requester = self.requester.clone();
+		let requester = self.requester.clone();
 
 		let (tx, rx) = oneshot::channel();
 		// Send a message from the rpc handler to the service level task.
 		requester
-			.send(((RequesterInput::Transaction(transaction_hash), params), tx))
-			.await
+			.unbounded_send(((RequesterInput::Transaction(transaction_hash), params), tx))
 			.map_err(|err| {
 				internal_err(format!(
 					"failed to send request to debug service : {:?}",
@@ -99,13 +98,12 @@ impl DebugServer for Debug {
 		id: RequestBlockId,
 		params: Option<TraceParams>,
 	) -> RpcResult<Vec<single::TransactionTrace>> {
-		let mut requester = self.requester.clone();
+		let requester = self.requester.clone();
 
 		let (tx, rx) = oneshot::channel();
 		// Send a message from the rpc handler to the service level task.
 		requester
-			.send(((RequesterInput::Block(id), params), tx))
-			.await
+			.unbounded_send(((RequesterInput::Block(id), params), tx))
 			.map_err(|err| {
 				internal_err(format!(
 					"failed to send request to debug service : {:?}",
@@ -329,7 +327,7 @@ where
 		};
 
 		// Get parent blockid.
-		let parent_block_id = BlockId::Hash(*header.parent_hash());
+		let parent_block_hash = *header.parent_hash();
 
 		let schema = fc_storage::onchain_storage_schema::<B, C, BE>(client.as_ref(), hash);
 
@@ -363,11 +361,11 @@ where
 
 		// Trace the block.
 		let f = || -> RpcResult<_> {
-			api.initialize_block(&parent_block_id, &header)
+			api.initialize_block(parent_block_hash, &header)
 				.map_err(|e| internal_err(format!("Runtime api access error: {:?}", e)))?;
 
 			let _result = api
-				.trace_block(&parent_block_id, exts, eth_tx_hashes)
+				.trace_block(parent_block_hash, exts, eth_tx_hashes)
 				.map_err(|e| {
 					internal_err(format!(
 						"Blockchain error when replaying block {} : {:?}",
@@ -460,7 +458,7 @@ where
 			_ => return Err(internal_err("Block header not found")),
 		};
 		// Get parent blockid.
-		let parent_block_id = BlockId::Hash(*header.parent_hash());
+		let parent_block_hash = *header.parent_hash();
 
 		// Get block extrinsics.
 		let exts = blockchain
@@ -470,7 +468,7 @@ where
 
 		// Get DebugRuntimeApi version
 		let trace_api_version = if let Ok(Some(api_version)) =
-			api.api_version::<dyn DebugRuntimeApi<B>>(&parent_block_id)
+			api.api_version::<dyn DebugRuntimeApi<B>>(parent_block_hash)
 		{
 			api_version
 		} else {
@@ -499,12 +497,12 @@ where
 			let transactions = block.transactions;
 			if let Some(transaction) = transactions.get(index) {
 				let f = || -> RpcResult<_> {
-					api.initialize_block(&parent_block_id, &header)
+					api.initialize_block(parent_block_hash, &header)
 						.map_err(|e| internal_err(format!("Runtime api access error: {:?}", e)))?;
 
 					if trace_api_version >= 4 {
 						let _result = api
-							.trace_transaction(&parent_block_id, exts, &transaction)
+							.trace_transaction(parent_block_hash, exts, &transaction)
 							.map_err(|e| {
 								internal_err(format!(
 									"Runtime api access error (version {:?}): {:?}",
@@ -518,7 +516,7 @@ where
 							ethereum::TransactionV2::Legacy(tx) =>
 							{
 								#[allow(deprecated)]
-								api.trace_transaction_before_version_4(&parent_block_id, exts, &tx)
+								api.trace_transaction_before_version_4(parent_block_hash, exts, &tx)
 									.map_err(|e| {
 										internal_err(format!(
 											"Runtime api access error (legacy): {:?}",

client/rpc/trace/src/lib.rs

@@ -24,7 +24,7 @@
 //! - For each traced block an async task responsible to wait for a permit, spawn a blocking
 //!   task and waiting for the result, then send it to the main `CacheTask`.
 
-use futures::{select, stream::FuturesUnordered, FutureExt, SinkExt, StreamExt};
+use futures::{select, stream::FuturesUnordered, FutureExt, StreamExt};
 use std::{collections::BTreeMap, future::Future, marker::PhantomData, sync::Arc, time::Duration};
 use tokio::{
 	sync::{mpsc, oneshot, Semaphore},
@@ -34,7 +34,7 @@ use tracing::{instrument, Instrument};
 
 use sc_client_api::backend::{Backend, StateBackend, StorageProvider};
 use sc_utils::mpsc::TracingUnboundedSender;
-use sp_api::{ApiExt, BlockId, Core, HeaderT, ProvideRuntimeApi};
+use sp_api::{ApiExt, Core, HeaderT, ProvideRuntimeApi};
 use sp_block_builder::BlockBuilder;
 use sp_blockchain::{
 	Backend as BlockchainBackend, Error as BlockChainError, HeaderBackend, HeaderMetadata,
@@ -282,14 +282,13 @@ impl CacheRequester {
 	#[instrument(skip(self))]
 	pub async fn start_batch(&self, blocks: Vec<H256>) -> Result<CacheBatchId, String> {
 		let (response_tx, response_rx) = oneshot::channel();
-		let mut sender = self.0.clone();
+		let sender = self.0.clone();
 
 		sender
-			.send(CacheRequest::StartBatch {
+			.unbounded_send(CacheRequest::StartBatch {
 				sender: response_tx,
 				blocks,
 			})
-			.await
 			.map_err(|e| {
 				format!(
 					"Failed to send request to the trace cache task. Error : {:?}",
@@ -312,14 +311,13 @@ impl CacheRequester {
 	#[instrument(skip(self))]
 	pub async fn get_traces(&self, block: H256) -> TxsTraceRes {
 		let (response_tx, response_rx) = oneshot::channel();
-		let mut sender = self.0.clone();
+		let sender = self.0.clone();
 
 		sender
-			.send(CacheRequest::GetTraces {
+			.unbounded_send(CacheRequest::GetTraces {
 				sender: response_tx,
 				block,
 			})
-			.await
 			.map_err(|e| {
 				format!(
 					"Failed to send request to the trace cache task. Error : {:?}",
@@ -342,13 +340,12 @@ impl CacheRequester {
 	/// this batch and still in the waiting pool will be discarded.
 	#[instrument(skip(self))]
 	pub async fn stop_batch(&self, batch_id: CacheBatchId) {
-		let mut sender = self.0.clone();
+		let sender = self.0.clone();
 
 		// Here we don't care if the request has been accepted or refused, the caller can't
 		// do anything with it.
 		let _ = sender
-			.send(CacheRequest::StopBatch { batch_id })
-			.await
+			.unbounded_send(CacheRequest::StopBatch { batch_id })
 			.map_err(|e| {
 				format!(
 					"Failed to send request to the trace cache task. Error : {:?}",
@@ -787,7 +784,7 @@ where
 			.ok_or_else(|| format!("Subtrate block {} don't exist", substrate_hash))?;
 
 		let height = *block_header.number();
-		let substrate_parent_id = BlockId::<B>::Hash(*block_header.parent_hash());
+		let substrate_parent_hash = *block_header.parent_hash();
 
 		let schema =
 			fc_storage::onchain_storage_schema::<B, C, BE>(client.as_ref(), substrate_hash);
@@ -829,11 +826,11 @@ where
 
 		// Trace the block.
 		let f = || -> Result<_, String> {
-			api.initialize_block(&substrate_parent_id, &block_header)
+			api.initialize_block(substrate_parent_hash, &block_header)
 				.map_err(|e| format!("Runtime api access error: {:?}", e))?;
 
 			let _result = api
-				.trace_block(&substrate_parent_id, extrinsics, eth_tx_hashes)
+				.trace_block(substrate_parent_hash, extrinsics, eth_tx_hashes)
 				.map_err(|e| format!("Blockchain error when replaying block {} : {:?}", height, e))?
 				.map_err(|e| {
 					tracing::warn!(

client/rpc/txpool/src/lib.rs

@@ -24,7 +24,7 @@ use sc_transaction_pool::{ChainApi, Pool};
 use sc_transaction_pool_api::InPoolTransaction;
 use serde::Serialize;
 use sha3::{Digest, Keccak256};
-use sp_api::{ApiExt, BlockId, ProvideRuntimeApi};
+use sp_api::{ApiExt, ProvideRuntimeApi};
 use sp_blockchain::{Error as BlockChainError, HeaderBackend, HeaderMetadata};
 use sp_runtime::traits::Block as BlockT;
 use std::collections::HashMap;
@@ -73,20 +73,19 @@ where
 			.collect();
 
 		// Use the runtime to match the (here) opaque extrinsics against ethereum transactions.
-		let best_block: BlockId<B> = BlockId::Hash(self.client.info().best_hash);
+		let best_block = self.client.info().best_hash;
 		let api = self.client.runtime_api();
-		let api_version = if let Ok(Some(api_version)) =
-			api.api_version::<dyn TxPoolRuntimeApi<B>>(&best_block)
-		{
-			api_version
-		} else {
-			return Err(internal_err(
-				"failed to retrieve Runtime Api version".to_string(),
-			));
-		};
+		let api_version =
+			if let Ok(Some(api_version)) = api.api_version::<dyn TxPoolRuntimeApi<B>>(best_block) {
+				api_version
+			} else {
+				return Err(internal_err(
+					"failed to retrieve Runtime Api version".to_string(),
+				));
+			};
 		let ethereum_txns: TxPoolResponse = if api_version == 1 {
 			#[allow(deprecated)]
-			let res = api.extrinsic_filter_before_version_2(&best_block, txs_ready, txs_future)
+			let res = api.extrinsic_filter_before_version_2(best_block, txs_ready, txs_future)
 				.map_err(|err| {
 					internal_err(format!("fetch runtime extrinsic filter failed: {:?}", err))
 				})?;
@@ -103,7 +102,7 @@ where
 					.collect(),
 			}
 		} else {
-			api.extrinsic_filter(&best_block, txs_ready, txs_future)
+			api.extrinsic_filter(best_block, txs_ready, txs_future)
 				.map_err(|err| {
 					internal_err(format!("fetch runtime extrinsic filter failed: {:?}", err))
 				})?