make xcm asset exchanger generic over pool type with default pool

runtime/adapters/src/tests/xcm_exchange.rs

@@ -2,16 +2,20 @@ use crate::tests::mock::AccountId;
 use crate::tests::mock::AssetId as CurrencyId;
 use crate::tests::mock::*;
 use crate::tests::mock::{DAI, HDX, NATIVE_AMOUNT};
-use crate::xcm_exchange::OmniExchanger;
+use crate::xcm_exchange::XcmAssetExchanger;
 use frame_support::{assert_noop, assert_ok, parameter_types};
+use hydradx_traits::router::PoolType;
 use orml_traits::MultiCurrency;
 use polkadot_xcm::latest::prelude::*;
 use pretty_assertions::assert_eq;
 use sp_runtime::traits::Convert;
 use sp_runtime::{FixedU128, SaturatedConversion};
 use xcm_executor::traits::AssetExchange;
+use xcm_executor::Assets;
+
 parameter_types! {
 	pub ExchangeTempAccount: AccountId = 12345;
+	pub DefaultPoolType: PoolType<crate::tests::mock::AssetId>  = PoolType::Omnipool;
 }
 
 const BUY: bool = false;
@@ -58,12 +62,11 @@ fn omni_exchanger_allows_selling_supported_assets() {
 		.execute_with(|| {
 			let give = MultiAsset::from((GeneralIndex(DAI.into()), 100 * UNITS)).into();
 			let wanted_amount = 45 * UNITS; // 50 - 5 to cover fees
-			let want = MultiAsset::from((GeneralIndex(HDX.into()), wanted_amount)).into();
+			let want: MultiAssets = MultiAsset::from((GeneralIndex(HDX.into()), wanted_amount)).into();
+
 			// Act
-			let received = OmniExchanger::<Test, ExchangeTempAccount, CurrencyIdConvert, Currencies>::exchange_asset(
-				None, give, &want, SELL,
-			)
-			.expect("should return ok");
+			let received = exchange_asset(None, give, &want, SELL).expect("should return ok");
+
 			// Assert
 			let mut iter = received.fungible_assets_iter();
 			let asset_received = iter.next().expect("there should be at least one asset");
@@ -91,12 +94,11 @@ fn omni_exchanger_allows_buying_supported_assets() {
 			let give = give_asset.into();
 			let wanted_amount = 45 * UNITS; // 50 - 5 to cover fees
 			let want_asset = MultiAsset::from((GeneralIndex(HDX.into()), wanted_amount));
-			let want = want_asset.clone().into();
+			let want: MultiAssets = want_asset.clone().into();
+
 			// Act
-			let received = OmniExchanger::<Test, ExchangeTempAccount, CurrencyIdConvert, Currencies>::exchange_asset(
-				None, give, &want, BUY,
-			)
-			.expect("should return ok");
+			let received = exchange_asset(None, give, &want, BUY).expect("should return ok");
+
 			// Assert
 			let mut iter = received.fungible_assets_iter();
 			let asset_received = iter.next().expect("there should be at least one asset");
@@ -131,15 +133,7 @@ fn omni_exchanger_should_not_allow_trading_for_multiple_assets() {
 			let want: MultiAssets = vec![want1, want2].into();
 
 			// Act and assert
-			assert_noop!(
-				OmniExchanger::<Test, ExchangeTempAccount, CurrencyIdConvert, Currencies>::exchange_asset(
-					None,
-					give.clone().into(),
-					&want,
-					SELL
-				),
-				give
-			);
+			assert_noop!(exchange_asset(None, give.clone().into(), &want, SELL), give);
 		});
 }
 
@@ -157,14 +151,19 @@ fn omni_exchanger_works_with_specified_origin() {
 			let give = MultiAsset::from((GeneralIndex(DAI.into()), 100 * UNITS)).into();
 			let wanted_amount = 45 * UNITS; // 50 - 5 to cover fees
 			let want = MultiAsset::from((GeneralIndex(HDX.into()), wanted_amount)).into();
-			// Act
-			assert_ok!(
-				OmniExchanger::<Test, ExchangeTempAccount, CurrencyIdConvert, Currencies>::exchange_asset(
-					Some(&MultiLocation::here()),
-					give,
-					&want,
-					SELL,
-				)
-			);
+
+			// Act and assert
+			assert_ok!(exchange_asset(Some(&MultiLocation::here()), give, &want, SELL));
 		});
 }
+
+fn exchange_asset(
+	origin: Option<&MultiLocation>,
+	give: Assets,
+	want: &MultiAssets,
+	is_sell: bool,
+) -> Result<Assets, Assets> {
+	XcmAssetExchanger::<Test, ExchangeTempAccount, CurrencyIdConvert, Currencies, DefaultPoolType>::exchange_asset(
+		origin, give, want, is_sell,
+	)
+}

runtime/adapters/src/xcm_exchange.rs

@@ -1,4 +1,4 @@
-use hydradx_traits::router::PoolType::Omnipool;
+use hydradx_traits::router::PoolType;
 use orml_traits::MultiCurrency;
 use pallet_route_executor::Trade;
 use polkadot_xcm::latest::prelude::*;
@@ -8,18 +8,19 @@ use sp_std::marker::PhantomData;
 use sp_std::vec;
 use xcm_executor::traits::AssetExchange;
 
-pub struct OmniExchanger<T, TempAccount, CurrencyIdConvert, Currency>(
-	PhantomData<(T, TempAccount, CurrencyIdConvert, Currency)>,
+pub struct XcmAssetExchanger<Runtime, TempAccount, CurrencyIdConvert, Currency, DefaultPoolType>(
+	PhantomData<(Runtime, TempAccount, CurrencyIdConvert, Currency, DefaultPoolType)>,
 );
 
-impl<T, TempAccount, CurrencyIdConvert, Currency> AssetExchange
-	for OmniExchanger<T, TempAccount, CurrencyIdConvert, Currency>
+impl<Runtime, TempAccount, CurrencyIdConvert, Currency, DefaultPoolType> AssetExchange
+	for XcmAssetExchanger<Runtime, TempAccount, CurrencyIdConvert, Currency, DefaultPoolType>
 where
-	T: pallet_route_executor::Config,
-	TempAccount: Get<T::AccountId>,
-	CurrencyIdConvert: Convert<MultiAsset, Option<T::AssetId>>,
-	Currency: MultiCurrency<T::AccountId, CurrencyId = T::AssetId, Balance = T::Balance>,
-	T::Balance: From<u128> + Zero + Into<u128>,
+	Runtime: pallet_route_executor::Config,
+	TempAccount: Get<Runtime::AccountId>,
+	CurrencyIdConvert: Convert<MultiAsset, Option<Runtime::AssetId>>,
+	Currency: MultiCurrency<Runtime::AccountId, CurrencyId = Runtime::AssetId, Balance = Runtime::Balance>,
+	Runtime::Balance: From<u128> + Zero + Into<u128>,
+	DefaultPoolType: Get<PoolType<Runtime::AssetId>>,
 {
 	fn exchange_asset(
 		_origin: Option<&MultiLocation>,
@@ -30,7 +31,7 @@ where
 		use orml_utilities::with_transaction_result;
 
 		let account = TempAccount::get();
-		let origin = T::RuntimeOrigin::from(frame_system::RawOrigin::Signed(account.clone())); //TODO: check how else it is done in hydra in a simpler way
+		let origin = Runtime::RuntimeOrigin::from(frame_system::RawOrigin::Signed(account.clone())); //TODO: check how else it is done in hydra in a simpler way
 
 		if give.len() != 1 {
 			log::warn!(target: "xcm::exchange-asset", "Only one give asset is supported.");
@@ -57,20 +58,20 @@ where
 
 			with_transaction_result(|| {
 				Currency::deposit(asset_in, &account, amount.into())?; // mint the incoming tokens
-				pallet_route_executor::Pallet::<T>::sell(
+				pallet_route_executor::Pallet::<Runtime>::sell(
 					origin,
 					asset_in,
 					asset_out,
 					amount.into(),
 					min_buy_amount.into(),
 					vec![Trade {
-						pool: Omnipool,
+						pool: DefaultPoolType::get(),
 						asset_in,
 						asset_out,
 					}],
 				)?;
 				debug_assert!(
-					Currency::free_balance(asset_in, &account) == T::Balance::zero(),
+					Currency::free_balance(asset_in, &account) == Runtime::Balance::zero(),
 					"Sell should not leave any of the incoming asset."
 				);
 				let amount_received = Currency::free_balance(asset_out, &account);
@@ -89,21 +90,21 @@ where
 
 			with_transaction_result(|| {
 				Currency::deposit(asset_in, &account, max_sell_amount.into())?; // mint the incoming tokens
-				pallet_route_executor::Pallet::<T>::buy(
+				pallet_route_executor::Pallet::<Runtime>::buy(
 					origin,
 					asset_in,
 					asset_out,
 					amount.into(),
 					max_sell_amount.into(),
 					vec![Trade {
-						pool: Omnipool,
+						pool: DefaultPoolType::get(),
 						asset_in,
 						asset_out,
 					}],
 				)?;
 				let mut assets = sp_std::vec::Vec::new();
 				let left_over = Currency::free_balance(asset_in, &account);
-				if left_over > T::Balance::zero() {
+				if left_over > Runtime::Balance::zero() {
 					Currency::withdraw(asset_in, &account, left_over)?; // burn left over tokens
 					assets.push(MultiAsset::from((given.id, left_over.into())));
 				}

runtime/hydradx/src/xcm.rs

@@ -13,6 +13,7 @@ use frame_support::{
 	PalletId,
 };
 use frame_system::EnsureRoot;
+use hydradx_traits::router::PoolType;
 use orml_traits::{location::AbsoluteReserveProvider, parameter_type_with_key};
 use orml_xcm_support::{DepositToAlternative, IsNativeConcrete, MultiNativeAsset};
 use pallet_xcm::XcmPassthrough;
@@ -82,6 +83,8 @@ parameter_types! {
 	pub const MaxInstructions: u32 = 100;
 	pub const MaxAssetsForTransfer: usize = 2;
 
+	pub DefaultPoolType: PoolType<AssetId>  = PoolType::Omnipool;
+
 	pub UniversalLocation: InteriorMultiLocation = X2(GlobalConsensus(RelayNetwork::get()), Parachain(ParachainInfo::parachain_id().into()));
 	pub TempAccount: AccountId = [42; 32].into();
 }
@@ -116,7 +119,7 @@ impl Config for XcmConfig {
 	type ResponseHandler = PolkadotXcm;
 	type AssetTrap = PolkadotXcm;
 	type AssetLocker = ();
-	type AssetExchanger = OmniExchanger<Runtime, TempAccount, CurrencyIdConvert, Currencies>;
+	type AssetExchanger = XcmAssetExchanger<Runtime, TempAccount, CurrencyIdConvert, Currencies, DefaultPoolType>;
 	type AssetClaims = PolkadotXcm;
 	type SubscriptionService = PolkadotXcm;
 	type PalletInstancesInfo = AllPalletsWithSystem;
@@ -220,7 +223,7 @@ impl pallet_xcm::Config for Runtime {
 }
 
 pub struct CurrencyIdConvert;
-use hydradx_adapters::xcm_exchange::OmniExchanger;
+use hydradx_adapters::xcm_exchange::XcmAssetExchanger;
 use primitives::constants::chain::CORE_ASSET_ID;
 
 impl Convert<AssetId, Option<MultiLocation>> for CurrencyIdConvert {