Update Substrate/Polkadot/Cumulus/Frontier dependency to 0.9.38

client/rpc-core/debug/Cargo.toml

@@ -16,4 +16,4 @@ moonbeam-rpc-core-types = { workspace = true }
 serde = { workspace = true, features = [ "derive" ] }
 serde_json = { workspace = true }
 
-sp-core = { git = "https://github.com/purestake/substrate", branch = "moonbeam-polkadot-v0.9.37" }
+sp-core = { workspace = true, features = [ "std" ] }

client/rpc/debug/Cargo.toml

@@ -35,4 +35,5 @@ ethereum-types = { workspace = true, features = [ "std" ] }
 fc-consensus = { workspace = true }
 fc-db = { workspace = true }
 fc-rpc = { workspace = true, features = [ "rpc-binary-search-estimate" ] }
+fc-storage = { workspace = true }
 fp-rpc = { workspace = true, features = [ "std" ] }

client/rpc/debug/src/lib.rs

@@ -308,7 +308,7 @@ where
 					frontier_backend.as_ref(),
 					eth_hash,
 				) {
-					Ok(Some(id)) => Ok(id),
+					Ok(Some(hash)) => Ok(BlockId::Hash(hash)),
 					Ok(_) => Err(internal_err("Block hash not found".to_string())),
 					Err(e) => Err(e),
 				}
@@ -331,16 +331,13 @@ where
 		// Get parent blockid.
 		let parent_block_id = BlockId::Hash(*header.parent_hash());
 
-		let schema = frontier_backend_client::onchain_storage_schema::<B, C, BE>(
-			client.as_ref(),
-			reference_id,
-		);
+		let schema = fc_storage::onchain_storage_schema::<B, C, BE>(client.as_ref(), hash);
 
 		// Using storage overrides we align with `:ethereum_schema` which will result in proper
 		// SCALE decoding in case of migration.
 		let statuses = match overrides.schemas.get(&schema) {
 			Some(schema) => schema
-				.current_transaction_statuses(&reference_id)
+				.current_transaction_statuses(hash)
 				.unwrap_or_default(),
 			_ => {
 				return Err(internal_err(format!(
@@ -446,7 +443,7 @@ where
 			frontier_backend.as_ref(),
 			hash,
 		) {
-			Ok(Some(hash)) => hash,
+			Ok(Some(hash)) => BlockId::Hash(hash),
 			Ok(_) => return Err(internal_err("Block hash not found".to_string())),
 			Err(e) => return Err(e),
 		};
@@ -482,19 +479,17 @@ where
 			));
 		};
 
-		let schema = frontier_backend_client::onchain_storage_schema::<B, C, BE>(
-			client.as_ref(),
-			reference_id,
-		);
+		let schema =
+			fc_storage::onchain_storage_schema::<B, C, BE>(client.as_ref(), reference_hash);
 
 		// Get the block that contains the requested transaction. Using storage overrides we align
 		// with `:ethereum_schema` which will result in proper SCALE decoding in case of migration.
 		let reference_block = match overrides.schemas.get(&schema) {
-			Some(schema) => schema.current_block(&reference_id),
+			Some(schema) => schema.current_block(reference_hash),
 			_ => {
 				return Err(internal_err(format!(
 					"No storage override at {:?}",
-					reference_id
+					reference_hash
 				)))
 			}
 		};

client/rpc/finality/src/lib.rs

@@ -20,7 +20,6 @@ use std::{marker::PhantomData, sync::Arc};
 //TODO ideally we wouldn't depend on BlockId here. Can we change frontier
 // so it's load_hash helper returns an H256 instead of wrapping it in a BlockId?
 use fc_db::Backend as FrontierBackend;
-use sp_api::BlockId;
 use sp_blockchain::HeaderBackend;
 use sp_runtime::traits::Block;
 
@@ -90,8 +89,7 @@ fn is_block_finalized_inner<B: Block<Hash = H256>, C: HeaderBackend<B> + 'static
 	let substrate_hash =
 		match frontier_backend_client::load_hash::<B, C>(client, backend, raw_hash)? {
 			// If we find this hash in the frontier data base, we know it is an eth hash
-			Some(BlockId::Hash(hash)) => hash,
-			Some(BlockId::Number(_)) => panic!("is_canon test only works with hashes."),
+			Some(hash) => hash,
 			// Otherwise, we assume this is a Substrate hash.
 			None => raw_hash,
 		};

client/rpc/manual-xcm/Cargo.toml

@@ -17,3 +17,4 @@ tokio = { workspace = true, features = [ "sync", "time" ] }
 xcm = { workspace = true }
 
 cumulus-primitives-core = { workspace = true, features = [ "std" ] }
+xcm-primitives = { workspace = true, features = [ "std" ] }

client/rpc/manual-xcm/src/lib.rs

@@ -18,6 +18,8 @@ use cumulus_primitives_core::XcmpMessageFormat;
 use jsonrpsee::{core::RpcResult, proc_macros::rpc};
 use parity_scale_codec::Encode;
 use xcm::latest::prelude::*;
+use xcm::opaque::lts::Weight;
+use xcm_primitives::DEFAULT_PROOF_SIZE;
 
 /// This RPC interface is used to manually submit XCM messages that will be injected into a
 /// parachain-enabled runtime. This allows testing XCM logic in a controlled way in integration
@@ -57,20 +59,19 @@ impl ManualXcmApiServer for ManualXcm {
 		let downward_message_channel = self.downward_message_channel.clone();
 		// If no message is supplied, inject a default one.
 		let msg = if msg.is_empty() {
-			xcm::VersionedXcm::<()>::V2(Xcm(vec![
-				ReserveAssetDeposited((Parent, 10000000000000).into()),
+			xcm::VersionedXcm::<()>::V3(Xcm(vec![
+				ReserveAssetDeposited((Parent, 10000000000000u128).into()),
 				ClearOrigin,
 				BuyExecution {
-					fees: (Parent, 10000000000000).into(),
-					weight_limit: Limited(4_000_000_000),
+					fees: (Parent, 10000000000000u128).into(),
+					weight_limit: Limited(Weight::from_parts(4_000_000_000u64, DEFAULT_PROOF_SIZE)),
 				},
 				DepositAsset {
-					assets: All.into(),
-					max_assets: 1,
+					assets: AllCounted(1).into(),
 					beneficiary: MultiLocation::new(
 						0,
 						X1(AccountKey20 {
-							network: Any,
+							network: None,
 							key: hex_literal::hex!("f24FF3a9CF04c71Dbc94D0b566f7A27B94566cac"),
 						}),
 					),
@@ -98,22 +99,24 @@ impl ManualXcmApiServer for ManualXcm {
 		let msg = if msg.is_empty() {
 			let mut mes = XcmpMessageFormat::ConcatenatedVersionedXcm.encode();
 			mes.append(
-				&mut (xcm::VersionedXcm::<()>::V2(Xcm(vec![
+				&mut (xcm::VersionedXcm::<()>::V3(Xcm(vec![
 					ReserveAssetDeposited(
-						((Parent, Parachain(sender.into())), 10000000000000).into(),
+						((Parent, Parachain(sender.into())), 10000000000000u128).into(),
 					),
 					ClearOrigin,
 					BuyExecution {
-						fees: ((Parent, Parachain(sender.into())), 10000000000000).into(),
-						weight_limit: Limited(4_000_000_000),
+						fees: ((Parent, Parachain(sender.into())), 10000000000000u128).into(),
+						weight_limit: Limited(Weight::from_parts(
+							4_000_000_000u64,
+							DEFAULT_PROOF_SIZE,
+						)),
 					},
 					DepositAsset {
-						assets: All.into(),
-						max_assets: 1,
+						assets: AllCounted(1).into(),
 						beneficiary: MultiLocation::new(
 							0,
 							X1(AccountKey20 {
-								network: Any,
+								network: None,
 								key: hex_literal::hex!("f24FF3a9CF04c71Dbc94D0b566f7A27B94566cac"),
 							}),
 						),

client/rpc/trace/Cargo.toml

@@ -39,4 +39,5 @@ sp-transaction-pool = { workspace = true }
 fc-consensus = { workspace = true }
 fc-rpc = { workspace = true, features = [ "rpc-binary-search-estimate" ] }
 fc-rpc-core = { workspace = true }
+fc-storage = { workspace = true }
 fp-rpc = { workspace = true }

client/rpc/trace/src/lib.rs

@@ -42,7 +42,7 @@ use sp_blockchain::{
 use sp_runtime::traits::{BlakeTwo256, Block as BlockT};
 
 use ethereum_types::H256;
-use fc_rpc::{frontier_backend_client, OverrideHandle};
+use fc_rpc::OverrideHandle;
 use fp_rpc::EthereumRuntimeRPCApi;
 
 use moonbeam_client_evm_tracing::{
@@ -774,8 +774,6 @@ where
 		substrate_hash: H256,
 		overrides: Arc<OverrideHandle<B>>,
 	) -> TxsTraceRes {
-		let substrate_block_id = BlockId::Hash(substrate_hash);
-
 		// Get Subtrate block data.
 		let api = client.runtime_api();
 		let block_header = client
@@ -786,31 +784,29 @@ where
 					substrate_hash, e
 				)
 			})?
-			.ok_or_else(|| format!("Subtrate block {} don't exist", substrate_block_id))?;
+			.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 schema = frontier_backend_client::onchain_storage_schema::<B, C, BE>(
-			client.as_ref(),
-			substrate_block_id,
-		);
+		let schema =
+			fc_storage::onchain_storage_schema::<B, C, BE>(client.as_ref(), substrate_hash);
 
 		// Get Ethereum block data.
 		let (eth_block, eth_transactions) = match overrides.schemas.get(&schema) {
 			Some(schema) => match (
-				schema.current_block(&substrate_block_id),
-				schema.current_transaction_statuses(&substrate_block_id),
+				schema.current_block(substrate_hash),
+				schema.current_transaction_statuses(substrate_hash),
 			) {
 				(Some(a), Some(b)) => (a, b),
 				_ => {
 					return Err(format!(
 						"Failed to get Ethereum block data for Substrate block {}",
-						substrate_block_id
+						substrate_hash
 					))
 				}
 			},
-			_ => return Err(format!("No storage override at {:?}", substrate_block_id)),
+			_ => return Err(format!("No storage override at {:?}", substrate_hash)),
 		};
 
 		let eth_block_hash = eth_block.header.hash();

node/service/src/client.rs

@@ -320,7 +320,7 @@ impl sc_client_api::StorageProvider<Block, crate::FullBackend> for Client {
 		prefix: Option<&'a StorageKey>,
 		start_key: Option<&StorageKey>,
 	) -> sp_blockchain::Result<
-		KeyIterator<'a, <crate::FullBackend as sc_client_api::Backend<Block>>::State, Block>,
+		KeyIterator<<crate::FullBackend as sc_client_api::Backend<Block>>::State, Block>,
 	> {
 		match_client!(self, storage_keys_iter(hash, prefix, start_key))
 	}
@@ -350,7 +350,7 @@ impl sc_client_api::StorageProvider<Block, crate::FullBackend> for Client {
 		prefix: Option<&'a StorageKey>,
 		start_key: Option<&StorageKey>,
 	) -> sp_blockchain::Result<
-		KeyIterator<'a, <crate::FullBackend as sc_client_api::Backend<Block>>::State, Block>,
+		KeyIterator<<crate::FullBackend as sc_client_api::Backend<Block>>::State, Block>,
 	> {
 		match_client!(
 			self,

node/service/src/lib.rs

@@ -30,7 +30,7 @@ use cumulus_client_network::BlockAnnounceValidator;
 use cumulus_client_service::{
 	prepare_node_config, start_collator, start_full_node, StartCollatorParams, StartFullNodeParams,
 };
-use cumulus_primitives_core::relay_chain::v2::CollatorPair;
+use cumulus_primitives_core::relay_chain::CollatorPair;
 use cumulus_primitives_core::ParaId;
 use cumulus_primitives_parachain_inherent::{
 	MockValidationDataInherentDataProvider, MockXcmConfig,

node/service/src/rpc.rs

@@ -121,30 +121,26 @@ pub struct TracingConfig {
 	pub trace_filter_max_count: u32,
 }
 
-pub fn overrides_handle<C, BE>(client: Arc<C>) -> Arc<OverrideHandle<Block>>
+pub fn overrides_handle<B, C, BE>(client: Arc<C>) -> Arc<OverrideHandle<B>>
 where
-	C: ProvideRuntimeApi<Block> + StorageProvider<Block, BE> + AuxStore,
-	C: HeaderBackend<Block> + HeaderMetadata<Block, Error = BlockChainError>,
-	C: Send + Sync + 'static,
-	C::Api: fp_rpc::EthereumRuntimeRPCApi<Block>,
-	BE: Backend<Block> + 'static,
-	BE::State: StateBackend<BlakeTwo256>,
+	B: BlockT,
+	C: ProvideRuntimeApi<B>,
+	C::Api: EthereumRuntimeRPCApi<B>,
+	C: HeaderBackend<B> + StorageProvider<B, BE> + 'static,
+	BE: Backend<B> + 'static,
 {
 	let mut overrides_map = BTreeMap::new();
 	overrides_map.insert(
 		EthereumStorageSchema::V1,
-		Box::new(SchemaV1Override::new(client.clone()))
-			as Box<dyn StorageOverride<_> + Send + Sync>,
+		Box::new(SchemaV1Override::new(client.clone())) as Box<dyn StorageOverride<_>>,
 	);
 	overrides_map.insert(
 		EthereumStorageSchema::V2,
-		Box::new(SchemaV2Override::new(client.clone()))
-			as Box<dyn StorageOverride<_> + Send + Sync>,
+		Box::new(SchemaV2Override::new(client.clone())) as Box<dyn StorageOverride<_>>,
 	);
 	overrides_map.insert(
 		EthereumStorageSchema::V3,
-		Box::new(SchemaV3Override::new(client.clone()))
-			as Box<dyn StorageOverride<_> + Send + Sync>,
+		Box::new(SchemaV3Override::new(client.clone())) as Box<dyn StorageOverride<_>>,
 	);
 
 	Arc::new(OverrideHandle {