Merge pull request #1242 from galacticcouncil/fix/evm-set-currency-erc20

fix: evm set currency for erc20

Author: enthusiastmartin

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "runtime-integration-tests"
-version = "1.55.0"
+version = "1.56.0"
 description = "Integration tests"
 authors = ["GalacticCouncil"]
 edition = "2021"

integration-tests/Cargo.toml

@@ -738,8 +738,6 @@ fn evm_permit_set_currency_dispatch_should_pay_evm_fee_in_chosen_erc20_currency(
 		));
 		let fee_currency = asset;
 
-		//let fee_currency = DAI;
-
 		init_omnipool_with_oracle_for_block_10();
 		//Add new erc20 token to omnipool and populate oracle
 		assert_ok!(hydradx_runtime::Omnipool::add_token(
@@ -864,6 +862,177 @@ fn evm_permit_set_currency_dispatch_should_pay_evm_fee_in_chosen_erc20_currency(
 	})
 }
 
+#[test]
+fn evm_permit_set_currency_dispatch_should_work_when_wrapped_in_dispatch_with_extra_gas_by_frontend() {
+	TestNet::reset();
+
+	let user_evm_address = alith_evm_address();
+	let user_secret_key = alith_secret_key();
+	let user_acc = MockAccount::new(alith_truncated_account());
+	let treasury_acc = MockAccount::new(Treasury::account_id());
+
+	Hydra::execute_with(|| {
+		//Create new erc20, fund user with it and set it as fee payment currency
+		let contract = crate::erc20::deploy_token_contract();
+		let asset = crate::erc20::bind_erc20(contract);
+		let balance = Currencies::free_balance(asset, &ALICE.into());
+		let initial_treasury_fee_balance = treasury_acc.balance(asset);
+		let erc20_balance = 2000000000000000;
+		assert_eq!(erc20_balance, 2000000000000000);
+		assert_ok!(<Erc20Currency<Runtime> as ERC20>::transfer(
+			CallContext {
+				contract: contract,
+				sender: crate::erc20::deployer(),
+				origin: crate::erc20::deployer()
+			},
+			user_evm_address,
+			erc20_balance
+		));
+
+		assert_ok!(Currencies::transfer(
+			hydradx_runtime::RuntimeOrigin::signed(alith_evm_account()),
+			hydradx_runtime::Omnipool::protocol_account(),
+			asset,
+			erc20_balance / 2
+		));
+
+		let alith_balance = Currencies::free_balance(asset, &alith_evm_account().into());
+		assert_eq!(alith_balance, erc20_balance / 2);
+
+		assert_ok!(MultiTransactionPayment::add_currency(
+			hydradx_runtime::RuntimeOrigin::root(),
+			asset,
+			FixedU128::from_rational(1, 2)
+		));
+		assert_ok!(MultiTransactionPayment::set_currency(
+			hydradx_runtime::RuntimeOrigin::signed(alith_evm_account()),
+			DAI,
+		));
+		let fee_currency = asset;
+
+		init_omnipool_with_oracle_for_block_10();
+		//Add new erc20 token to omnipool and populate oracle
+		assert_ok!(hydradx_runtime::Omnipool::add_token(
+			hydradx_runtime::RuntimeOrigin::root(),
+			asset,
+			FixedU128::from_rational(1, 2),
+			Permill::from_percent(100),
+			AccountId::from(alith_evm_account()),
+		));
+		assert_ok!(Omnipool::sell(
+			RuntimeOrigin::signed(alith_evm_account()),
+			asset,
+			0,
+			erc20_balance / 10,
+			Balance::MIN
+		));
+		hydradx_run_to_next_block();
+
+		pallet_transaction_payment::pallet::NextFeeMultiplier::<hydradx_runtime::Runtime>::put(
+			hydradx_runtime::MinimumMultiplier::get(),
+		);
+
+		let initial_user_fee_currency_balance = user_acc.balance(fee_currency);
+		let initial_user_weth_balance = user_acc.balance(WETH);
+
+		let initial_fee_currency_issuance = Currencies::total_issuance(fee_currency);
+
+		// just reset the weth balance to 0 - to make sure we don't have enough WETH
+		assert_ok!(hydradx_runtime::Currencies::update_balance(
+			hydradx_runtime::RuntimeOrigin::root(),
+			user_acc.address(),
+			WETH,
+			-(initial_user_weth_balance as i128),
+		));
+
+		let initial_user_weth_balance = user_acc.balance(WETH);
+		assert_eq!(initial_user_weth_balance, 0);
+
+		let set_currency_call = hydradx_runtime::RuntimeCall::MultiTransactionPayment(
+			pallet_transaction_multi_payment::Call::set_currency { currency: fee_currency },
+		);
+		let dispatch_set_currency_call =
+			hydradx_runtime::RuntimeCall::Dispatcher(pallet_dispatcher::Call::dispatch_with_extra_gas {
+				call: Box::new(set_currency_call.clone()),
+				extra_gas: 100_000,
+			});
+
+		let gas_limit = 1000000;
+		let deadline = U256::from(1000000000000u128);
+
+		let permit =
+			pallet_evm_precompile_call_permit::CallPermitPrecompile::<hydradx_runtime::Runtime>::generate_permit(
+				CALLPERMIT,
+				user_evm_address,
+				DISPATCH_ADDR,
+				U256::from(0),
+				dispatch_set_currency_call.encode(),
+				gas_limit,
+				U256::zero(),
+				deadline,
+			);
+		let secret_key = SecretKey::parse(&user_secret_key).unwrap();
+		let message = Message::parse(&permit);
+		let (rs, v) = sign(&message, &secret_key);
+
+		// Validate unsigned first
+		let call: pallet_transaction_multi_payment::Call<hydradx_runtime::Runtime> =
+			pallet_transaction_multi_payment::Call::dispatch_permit {
+				from: user_evm_address,
+				to: DISPATCH_ADDR,
+				value: U256::from(0),
+				data: dispatch_set_currency_call.encode(),
+				gas_limit,
+				deadline,
+				v: v.serialize(),
+				r: H256::from(rs.r.b32()),
+				s: H256::from(rs.s.b32()),
+			};
+
+		let tag: Vec<u8> = ("EVMPermit", (U256::zero(), user_evm_address)).encode();
+		assert_eq!(
+			MultiTransactionPayment::validate_unsigned(TransactionSource::External, &call),
+			Ok(ValidTransaction {
+				priority: 0,
+				requires: vec![],
+				provides: vec![tag],
+				longevity: 64,
+				propagate: true,
+			})
+		);
+
+		// And Dispatch
+		assert_ok!(MultiTransactionPayment::dispatch_permit(
+			hydradx_runtime::RuntimeOrigin::none(),
+			user_evm_address,
+			DISPATCH_ADDR,
+			U256::from(0),
+			dispatch_set_currency_call.encode(),
+			gas_limit,
+			deadline,
+			v.serialize(),
+			H256::from(rs.r.b32()),
+			H256::from(rs.s.b32()),
+		));
+
+		let currency =
+			pallet_transaction_multi_payment::Pallet::<hydradx_runtime::Runtime>::account_currency(&user_acc.address());
+		assert_eq!(currency, fee_currency);
+
+		let fee_currency_issuance = Currencies::total_issuance(fee_currency);
+		assert_eq!(initial_fee_currency_issuance, fee_currency_issuance);
+
+		let user_fee_currency_balance = user_acc.balance(fee_currency);
+		assert!(user_fee_currency_balance < initial_user_fee_currency_balance);
+		let final_treasury_fee_balance = treasury_acc.balance(asset);
+
+		assert!(final_treasury_fee_balance > initial_treasury_fee_balance);
+		let fee_amount = initial_user_fee_currency_balance - user_fee_currency_balance;
+		let treasury_received = final_treasury_fee_balance - initial_treasury_fee_balance;
+		assert_eq!(fee_amount, treasury_received);
+	})
+}
+
 #[test]
 fn evm_permit_set_currency_dispatch_should_pay_evm_fee_in_insufficient_asset() {
 	TestNet::reset();

integration-tests/src/evm_permit.rs

@@ -1,6 +1,6 @@
 [package]
 name = "pallet-transaction-multi-payment"
-version = "10.1.8"
+version = "10.2.0"
 description = "Transaction multi currency payment support module"
 authors = ["GalacticCoucil"]
 edition = "2021"

pallets/transaction-multi-payment/Cargo.toml

@@ -843,36 +843,6 @@ impl<T: Config> AccountFeeCurrency<T::AccountId> for Pallet<T> {
 	}
 }
 
-pub struct TryCallCurrency<T>(PhantomData<T>);
-impl<T> TryConvert<&<T as frame_system::Config>::RuntimeCall, AssetIdOf<T>> for TryCallCurrency<T>
-where
-	T: Config + pallet_utility::Config,
-	<T as frame_system::Config>::RuntimeCall: IsSubType<Call<T>> + IsSubType<pallet_utility::pallet::Call<T>>,
-	<T as pallet_utility::Config>::RuntimeCall: IsSubType<Call<T>>,
-{
-	fn try_convert(
-		call: &<T as frame_system::Config>::RuntimeCall,
-	) -> Result<AssetIdOf<T>, &<T as frame_system::Config>::RuntimeCall> {
-		if let Some(crate::pallet::Call::set_currency { currency }) = call.is_sub_type() {
-			Ok(*currency)
-		} else if let Some(pallet_utility::pallet::Call::batch { calls })
-		| Some(pallet_utility::pallet::Call::batch_all { calls })
-		| Some(pallet_utility::pallet::Call::force_batch { calls }) = call.is_sub_type()
-		{
-			// `calls` can be empty Vec
-			match calls.first() {
-				Some(first_call) => match first_call.is_sub_type() {
-					Some(crate::pallet::Call::set_currency { currency }) => Ok(*currency),
-					_ => Err(call),
-				},
-				_ => Err(call),
-			}
-		} else {
-			Err(call)
-		}
-	}
-}
-
 pub struct NoCallCurrency<T>(PhantomData<T>);
 impl<T: Config> TryConvert<&<T as frame_system::Config>::RuntimeCall, AssetIdOf<T>> for NoCallCurrency<T> {
 	fn try_convert(

pallets/transaction-multi-payment/src/lib.rs

@@ -1,6 +1,6 @@
 [package]
 name = "hydradx-runtime"
-version = "356.0.0"
+version = "357.0.0"
 authors = ["GalacticCouncil"]
 edition = "2021"
 license = "Apache 2.0"

runtime/hydradx/Cargo.toml

@@ -73,7 +73,7 @@ use pallet_staking::{
 	types::{Action, Point},
 	SigmoidPercentage,
 };
-use pallet_transaction_multi_payment::{AddTxAssetOnAccount, RemoveTxAssetOnKilled};
+use pallet_transaction_multi_payment::{AddTxAssetOnAccount, AssetIdOf, Call, Config, RemoveTxAssetOnKilled};
 use pallet_xyk::weights::WeightInfo as XykWeights;
 use primitives::constants::{
 	chain::{CORE_ASSET_ID, OMNIPOOL_SOURCE, XYK_SOURCE},
@@ -1402,6 +1402,7 @@ use hydradx_adapters::price::OraclePriceProviderUsingRoute;
 
 #[cfg(feature = "runtime-benchmarks")]
 use frame_support::storage::with_transaction;
+use frame_support::traits::IsSubType;
 use hydradx_traits::evm::{Erc20Inspect, Erc20OnDust};
 #[cfg(feature = "runtime-benchmarks")]
 use hydradx_traits::price::PriceProvider;
@@ -1421,6 +1422,7 @@ use pallet_referrals::{FeeDistribution, Level};
 use pallet_stableswap::types::PegType;
 #[cfg(feature = "runtime-benchmarks")]
 use pallet_stableswap::BenchmarkHelper;
+use sp_runtime::traits::TryConvert;
 use sp_runtime::TokenError;
 #[cfg(feature = "runtime-benchmarks")]
 use sp_runtime::TransactionOutcome;
@@ -2111,3 +2113,35 @@ impl Erc20OnDust<AccountId, AssetId> for ATokenAccountDuster {
 		Ok(())
 	}
 }
+
+pub struct TryCallCurrency;
+impl TryConvert<&<Runtime as frame_system::Config>::RuntimeCall, AssetIdOf<Runtime>> for TryCallCurrency {
+	fn try_convert(
+		call: &<Runtime as frame_system::Config>::RuntimeCall,
+	) -> Result<AssetIdOf<Runtime>, &<Runtime as frame_system::Config>::RuntimeCall> {
+		if let Some(pallet_transaction_multi_payment::pallet::Call::set_currency { currency }) = call.is_sub_type() {
+			Ok(*currency)
+		} else if let Some(pallet_utility::pallet::Call::batch { calls })
+		| Some(pallet_utility::pallet::Call::batch_all { calls })
+		| Some(pallet_utility::pallet::Call::force_batch { calls }) = call.is_sub_type()
+		{
+			// `calls` can be empty Vec
+			match calls.first() {
+				Some(first_call) => match first_call.is_sub_type() {
+					Some(pallet_transaction_multi_payment::pallet::Call::set_currency { currency }) => Ok(*currency),
+					_ => Err(call),
+				},
+				_ => Err(call),
+			}
+		} else if let Some(pallet_dispatcher::pallet::Call::dispatch_with_extra_gas { call: inner_call, .. }) =
+			call.is_sub_type()
+		{
+			match inner_call.is_sub_type() {
+				Some(pallet_transaction_multi_payment::pallet::Call::set_currency { currency }) => Ok(*currency),
+				_ => Err(call),
+			}
+		} else {
+			Err(call)
+		}
+	}
+}

runtime/hydradx/src/assets.rs

@@ -122,7 +122,7 @@ pub const VERSION: RuntimeVersion = RuntimeVersion {
 	spec_name: create_runtime_str!("hydradx"),
 	impl_name: create_runtime_str!("hydradx"),
 	authoring_version: 1,
-	spec_version: 356,
+	spec_version: 357,
 	impl_version: 0,
 	apis: RUNTIME_API_VERSIONS,
 	transaction_version: 1,

runtime/hydradx/src/lib.rs

@@ -620,7 +620,7 @@ impl pallet_transaction_multi_payment::Config for Runtime {
 	type InspectEvmAccounts = EVMAccounts;
 	type WeightToFee = WeightToFee;
 	type EvmPermit = evm::permit::EvmPermitHandler<Runtime>;
-	type TryCallCurrency<'a> = pallet_transaction_multi_payment::TryCallCurrency<Runtime>;
+	type TryCallCurrency<'a> = TryCallCurrency;
 	type SwappablePaymentAssetSupport = assets::XykPaymentAssetSupport;
 }