Update 0.9.38 (moonbeam-foundation#2145)

* Init

* update precompile xcm utils

* update precompile xcm utils tests

* update `pallet-erc20-xcm-bridge`

* update `pallet-erc20-xcm-bridge` tests

* update `xcm-primitives`

* update `xcm-primitives` tests

* update `pallet-xcm-transactor` + tests

* update `moonbeam-xcm-benchmarks` + tests

* update `pallet-evm-precompile-xtokens` + tests

* update `pallet-evm-precompile-xcm-transactor` + tests

* update `pallet-evm-precompile-xcm-utils` + tests

* update `moonbase-runtime` + tests

* cleanup

* update `moonriver-runtime` + tests

* update `moonbeam-runtime` + tests

* update `moonbeam-rpc-debug` and `moonbeam-rpc-trace`

* update `moonbeam-service`

* some additional fixes, cargo check green

* cleanup warnings

* fmt

* remove `XcmExecutorWrapper`

* editorconfig

* Update polkadot pin

* Fix test build

* Update `DEFAULT_PROOF_SIZE` in preocmpiles

* Update `pallet-evm-precompileset-assets-erc20` test weights

* Update `transact_through_signed_precompile_works_v1` test weight

* update `RemoveItemsLimit`

* wip fix ts tests

* update `RemoveItemsLimit` 2

* wip update benchmarks

* remove comment

* update benchmarks

* update `manual-xcm-rpc`

* fix remaining dep version updates

* wip fix ts tests

* remove `XcmExecuteFilterWrapper`

* comment on destroy accounts magic number

* use `DEFAULT_PROOF_SIZE` const

* comment on TODO handle proof size payment

* fix `test-mock-hrmp-queue`

* repin orml

* repin cumulus

* fix `test-mock-dmp-queue` test

* wip `pallet-asset-manager` migration

* `pallet-asset-manager` migration tests

* wip `pallet-xcm-transactor` migration

* `pallet-xcm-transactor` migration tests

* fmt

* toml-sort

* editorconfig

* remove unused

* prettier

* missing import

* repin polkadot

* migrate `RemoteTransactInfoWithMaxWeight`

* set 0.75 `MAX_POV_SIZE` moonbase only

* `pallet-asset-manager` fix pre and post upgrade tests

* `pallet-xcm-transactor` fix pre and post upgrade tests

* fmt

* repin substrate

* Revert "set 0.75 `MAX_POV_SIZE` moonbase only"

This reverts commit 65e723c.

* add defensive `transact_required_weight_at_most` value

* Increase `DEFAULT_PROOF_SIZE` to 128kb

* fmt

Author: tgmichel

Cargo.lock

@@ -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" ] }

Cargo.toml

@@ -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/debug/Cargo.toml

@@ -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/debug/src/lib.rs

@@ -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/finality/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/manual-xcm/Cargo.toml

@@ -39,4 +39,5 @@ sp-transaction-pool = { git = "https://github.com/paritytech/substrate", branch
 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/manual-xcm/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();

client/rpc/trace/Cargo.toml

@@ -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,