Allow Treasury to spend Foreign Assets (#3220)

Author: pLabarta

Cargo.lock

@@ -244,7 +244,7 @@ where
 		self.clone()
 			.filter(filter)
 			.await
-			.map_err(|e| fc_rpc::internal_err(e))
+			.map_err(fc_rpc::internal_err)
 	}
 }
 
@@ -709,7 +709,7 @@ where
 					tracing::trace!("Pooled block {} is no longer requested.", block);
 					// Remove block from the cache. Drops the value,
 					// closing all the channels contained in it.
-					let _ = self.cached_blocks.remove(&block);
+					let _ = self.cached_blocks.remove(block);
 				}
 			}
 		}

client/rpc/trace/src/lib.rs

@@ -8,6 +8,9 @@ version = "0.1.0"
 ethereum-types = { workspace = true }
 log = { workspace = true }
 
+# Moonbeam
+moonbeam-core-primitives = { workspace = true}
+
 # Substrate
 frame-support = { workspace = true }
 frame-system = { workspace = true }

pallets/moonbeam-foreign-assets/Cargo.toml

@@ -42,10 +42,12 @@ const ERC20_PAUSE_GAS_LIMIT: u64 = 160_000; // highest failure: 150_500
 pub(crate) const ERC20_TRANSFER_GAS_LIMIT: u64 = 160_000; // highest failure: 154_000
 pub(crate) const ERC20_APPROVE_GAS_LIMIT: u64 = 160_000; // highest failure: 153_000
 const ERC20_UNPAUSE_GAS_LIMIT: u64 = 160_000; // highest failure: 149_500
+pub(crate) const ERC20_BALANCE_OF_GAS_LIMIT: u64 = 160_000; // Calculated effective gas: max(used: 24276, pov: 150736, storage: 0) = 150736
 
 #[derive(Debug)]
 pub enum EvmError {
 	BurnFromFail(String),
+	BalanceOfFail(String),
 	ContractReturnInvalidValue,
 	DispatchError(DispatchError),
 	EvmCallFail(String),
@@ -66,6 +68,10 @@ impl From<EvmError> for XcmError {
 				log::debug!("BurnFromFail error: {:?}", err);
 				XcmError::FailedToTransactAsset("Erc20 contract call burnFrom fail")
 			}
+			EvmError::BalanceOfFail(err) => {
+				log::debug!("BalanceOfFail error: {:?}", err);
+				XcmError::FailedToTransactAsset("Erc20 contract call balanceOf fail")
+			}
 			EvmError::ContractReturnInvalidValue => {
 				XcmError::FailedToTransactAsset("Erc20 contract return invalid value")
 			}
@@ -449,6 +455,47 @@ impl<T: crate::Config> EvmCaller<T> {
 
 		Ok(())
 	}
+
+	// Call contract selector "balanceOf"
+	pub(crate) fn erc20_balance_of(asset_id: AssetId, account: H160) -> Result<U256, EvmError> {
+		let mut input = Vec::with_capacity(ERC20_CALL_MAX_CALLDATA_SIZE);
+		// Selector
+		input.extend_from_slice(&keccak256!("balanceOf(address)")[..4]);
+		// append account address
+		input.extend_from_slice(H256::from(account).as_bytes());
+
+		let exec_info = T::EvmRunner::call(
+			Pallet::<T>::account_id(),
+			Pallet::<T>::contract_address_from_asset_id(asset_id),
+			input,
+			U256::default(),
+			ERC20_BALANCE_OF_GAS_LIMIT,
+			None,
+			None,
+			None,
+			Default::default(),
+			false,
+			false,
+			None,
+			None,
+			&<T as pallet_evm::Config>::config(),
+		)
+		.map_err(|err| EvmError::EvmCallFail(format!("{:?}", err.error.into())))?;
+
+		ensure!(
+			matches!(
+				exec_info.exit_reason,
+				ExitReason::Succeed(ExitSucceed::Returned | ExitSucceed::Stopped)
+			),
+			{
+				let err = error_on_execution_failure(&exec_info.exit_reason, &exec_info.value);
+				EvmError::BalanceOfFail(err)
+			}
+		);
+
+		let balance = U256::from_big_endian(&exec_info.value);
+		Ok(balance)
+	}
 }
 
 fn error_on_execution_failure(reason: &ExitReason, data: &[u8]) -> String {

pallets/moonbeam-foreign-assets/src/evm.rs

@@ -55,6 +55,7 @@ use ethereum_types::{H160, U256};
 use frame_support::pallet;
 use frame_support::pallet_prelude::*;
 use frame_support::traits::Contains;
+
 use frame_system::pallet_prelude::*;
 use xcm::latest::{
 	Asset, AssetId as XcmAssetId, Error as XcmError, Fungibility, Location, Result as XcmResult,
@@ -247,6 +248,8 @@ pub mod pallet {
 		Erc20ContractCreationFail,
 		EvmCallPauseFail,
 		EvmCallUnpauseFail,
+		EvmCallMintIntoFail,
+		EvmCallTransferFail,
 		EvmInternalError,
 		/// Account has insufficient balance for locking
 		InsufficientBalance,
@@ -364,6 +367,29 @@ pub mod pallet {
 			.map_err(Into::into)
 		}
 
+		/// Transfer an asset from an account to another one
+		pub fn transfer(
+			asset_id: AssetId,
+			from: T::AccountId,
+			to: T::AccountId,
+			amount: U256,
+		) -> Result<(), evm::EvmError> {
+			frame_support::storage::with_storage_layer(|| {
+				EvmCaller::<T>::erc20_transfer(
+					Self::contract_address_from_asset_id(asset_id),
+					T::AccountIdToH160::convert(from),
+					T::AccountIdToH160::convert(to),
+					amount,
+				)
+			})
+			.map_err(Into::into)
+		}
+
+		pub fn balance(asset_id: AssetId, who: T::AccountId) -> Result<U256, evm::EvmError> {
+			EvmCaller::<T>::erc20_balance_of(asset_id, T::AccountIdToH160::convert(who))
+				.map_err(Into::into)
+		}
+
 		/// Aprrove a spender to spend a certain amount of tokens from the owner account
 		pub fn approve(
 			asset_id: AssetId,
@@ -754,4 +780,68 @@ pub mod pallet {
 			AssetsById::<T>::get(asset_id)
 		}
 	}
+
+	#[cfg(feature = "runtime-benchmarks")]
+	impl<T: Config> AssetCreate for Pallet<T> {
+		fn create_asset(id: u128, xcm_location: Location) -> DispatchResult {
+			use frame_support::traits::OriginTrait;
+			use sp_std::vec;
+			Pallet::<T>::create_foreign_asset(
+				<T as frame_system::Config>::RuntimeOrigin::root(),
+				id,
+				xcm_location,
+				12,
+				vec![b'M', b'T'].try_into().expect("invalid ticker"),
+				vec![b'M', b'y', b'T', b'o', b'k']
+					.try_into()
+					.expect("invalid name"),
+			)
+		}
+	}
+
+	impl<T: Config> AssetMutate<T> for Pallet<T> {
+		fn transfer_asset(
+			id: u128,
+			from: T::AccountId,
+			to: T::AccountId,
+			amount: U256,
+		) -> DispatchResult {
+			Pallet::<T>::transfer(id, from, to, amount)
+				.map_err(|_| Error::<T>::EvmCallTransferFail)?;
+			Ok(())
+		}
+
+		#[cfg(feature = "runtime-benchmarks")]
+		fn mint_asset(id: u128, account: T::AccountId, amount: U256) -> DispatchResult {
+			Pallet::<T>::mint_into(id, account, amount)
+				.map_err(|_| Error::<T>::EvmCallMintIntoFail)?;
+			Ok(())
+		}
+	}
+
+	impl<T: Config> AssetInspect for Pallet<T> {
+		fn asset_exists(id: u128) -> bool {
+			AssetsById::<T>::contains_key(&id)
+		}
+	}
+}
+
+pub trait AssetCreate {
+	fn create_asset(id: u128, xcm_location: Location) -> DispatchResult;
+}
+
+pub trait AssetMutate<R: frame_system::Config> {
+	fn transfer_asset(
+		id: u128,
+		from: R::AccountId,
+		to: R::AccountId,
+		amount: U256,
+	) -> DispatchResult;
+
+	#[cfg(feature = "runtime-benchmarks")]
+	fn mint_asset(id: u128, account: R::AccountId, amount: U256) -> DispatchResult;
+}
+
+pub trait AssetInspect {
+	fn asset_exists(id: u128) -> bool;
 }

pallets/moonbeam-foreign-assets/src/lib.rs

@@ -8,6 +8,10 @@ version = "0.1.0"
 [dependencies]
 log = { workspace = true }
 
+# Moonbeam
+moonbeam-core-primitives = { workspace = true }
+pallet-moonbeam-foreign-assets = { workspace = true}
+
 # Substrate
 frame-support = { workspace = true }
 frame-system = { workspace = true }
@@ -51,4 +55,4 @@ std = [
     "xcm-executor/std",
     "xcm-runtime-apis/std",
 ]
-try-runtime = ["frame-support/try-runtime"]
+try-runtime = ["frame-support/try-runtime"]

pallets/xcm-weight-trader/Cargo.toml

@@ -125,6 +125,8 @@ pub mod pallet {
 		XcmLocationFiltered,
 		/// The relative price cannot be zero
 		PriceCannotBeZero,
+		/// The relative price calculation overflowed
+		PriceOverflow,
 	}
 
 	#[pallet::event]
@@ -180,7 +182,7 @@ pub mod pallet {
 		}
 
 		#[pallet::call_index(1)]
-		#[pallet::weight(T::WeightInfo::edit_asset())]
+		#[pallet::weight(<T as pallet::Config>::WeightInfo::edit_asset())]
 		pub fn edit_asset(
 			origin: OriginFor<T>,
 			location: Location,
@@ -205,7 +207,7 @@ pub mod pallet {
 		}
 
 		#[pallet::call_index(2)]
-		#[pallet::weight(T::WeightInfo::pause_asset_support())]
+		#[pallet::weight(<T as pallet::Config>::WeightInfo::pause_asset_support())]
 		pub fn pause_asset_support(origin: OriginFor<T>, location: Location) -> DispatchResult {
 			T::PauseSupportedAssetOrigin::ensure_origin(origin)?;
 
@@ -221,7 +223,7 @@ pub mod pallet {
 		}
 
 		#[pallet::call_index(3)]
-		#[pallet::weight(T::WeightInfo::resume_asset_support())]
+		#[pallet::weight(<T as pallet::Config>::WeightInfo::resume_asset_support())]
 		pub fn resume_asset_support(origin: OriginFor<T>, location: Location) -> DispatchResult {
 			T::ResumeSupportedAssetOrigin::ensure_origin(origin)?;
 
@@ -237,7 +239,7 @@ pub mod pallet {
 		}
 
 		#[pallet::call_index(4)]
-		#[pallet::weight(T::WeightInfo::remove_asset())]
+		#[pallet::weight(<T as pallet::Config>::WeightInfo::remove_asset())]
 		pub fn remove_asset(origin: OriginFor<T>, location: Location) -> DispatchResult {
 			T::RemoveSupportedAssetOrigin::ensure_origin(origin)?;
 

pallets/xcm-weight-trader/src/lib.rs

@@ -203,7 +203,7 @@ impl XcmToEthereum for EthereumXcmTransactionV1 {
 					s: rs_id(),
 				}))
 			}
-			_ => return None,
+			_ => None,
 		}
 	}
 }
@@ -222,7 +222,7 @@ impl XcmToEthereum for EthereumXcmTransactionV2 {
 		let from_tuple_to_access_list = |t: &Vec<(H160, Vec<H256>)>| -> AccessList {
 			t.iter()
 				.map(|item| AccessListItem {
-					address: item.0.clone(),
+					address: item.0,
 					storage_keys: item.1.clone(),
 				})
 				.collect::<Vec<AccessListItem>>()

primitives/xcm/src/ethereum_xcm.rs

@@ -15,16 +15,22 @@
 // along with Moonbeam.  If not, see <http://www.gnu.org/licenses/>.
 
 use account::AccountId20;
+use frame_support::traits::fungible::NativeOrWithId;
+use moonbeam_core_primitives::AssetId;
 use pallet_treasury::ArgumentsFactory;
 
 pub struct BenchmarkHelper;
 
-impl ArgumentsFactory<(), AccountId20> for BenchmarkHelper {
-	fn create_asset_kind(_seed: u32) -> () {
-		()
+impl ArgumentsFactory<NativeOrWithId<AssetId>, AccountId20> for BenchmarkHelper {
+	fn create_asset_kind(seed: u32) -> NativeOrWithId<AssetId> {
+		NativeOrWithId::WithId(seed.into())
 	}
 
 	fn create_beneficiary(seed: [u8; 32]) -> AccountId20 {
+		// Avoid generating a zero address
+		if seed == [0; 32] {
+			return AccountId20::from([1; 32]);
+		}
 		AccountId20::from(seed)
 	}
 }