Pay XCM execution with local and foreign assets

parachains/runtimes/assets/asset-hub-polkadot/tests/tests.rs

@@ -114,7 +114,10 @@ fn test_asset_xcm_trader() {
  let mut trader = <XcmConfig as xcm_executor::Config>::Trader::new();
 
  // Lets buy_weight and make sure buy_weight does not return an error
- let unused_assets = trader.buy_weight(bought, asset.into()).expect("Expected Ok");
+ let unused_assets = trader
+ .buy_weight(&XcmContext::with_message_id([0; 32]), bought, asset.into())
+ .expect("Expected Ok");
+
  // Check whether a correct amount of unused assets is returned
  assert_ok!(
  unused_assets.ensure_contains(&(asset_multilocation, asset_amount_extra).into())
@@ -184,12 +187,14 @@ fn test_asset_xcm_trader_with_refund() {
 
  let asset: MultiAsset = (asset_multilocation, amount_bought).into();
 
+ let ctx = XcmContext::with_message_id([0; 32]);
+
  // Make sure buy_weight does not return an error
- assert_ok!(trader.buy_weight(bought, asset.clone().into()));
+ assert_ok!(trader.buy_weight(&ctx, bought, asset.clone().into()));
 
  // Make sure again buy_weight does return an error
  // This assert relies on the fact, that we use `TakeFirstAssetTrader` in `WeightTrader` tuple chain, which cannot be called twice
- assert_noop!(trader.buy_weight(bought, asset.into()), XcmError::TooExpensive);
+ assert_noop!(trader.buy_weight(&ctx, bought, asset.into()), XcmError::TooExpensive);
 
  // We actually use half of the weight
  let weight_used = bought / 2;
@@ -198,7 +203,7 @@ fn test_asset_xcm_trader_with_refund() {
  let amount_refunded = WeightToFee::weight_to_fee(&(bought - weight_used));
 
  assert_eq!(
- trader.refund_weight(bought - weight_used),
+ trader.refund_weight(&ctx, bought - weight_used),
  Some((asset_multilocation, amount_refunded).into())
  );
 
@@ -262,7 +267,10 @@ fn test_asset_xcm_trader_refund_not_possible_since_amount_less_than_ed() {
  let asset: MultiAsset = (asset_multilocation, amount_bought).into();
 
  // Buy weight should return an error
- assert_noop!(trader.buy_weight(bought, asset.into()), XcmError::TooExpensive);
+ assert_noop!(
+ trader.buy_weight(&XcmContext::with_message_id([0; 32]), bought, asset.into()),
+ XcmError::TooExpensive
+ );
 
  // not credited since the ED is higher than this value
  assert_eq!(Assets::balance(1, AccountId::from(ALICE)), 0);
@@ -313,17 +321,24 @@ fn test_that_buying_ed_refund_does_not_refund() {
  // We know we will have to buy at least ED, so lets make sure first it will
  // fail with a payment of less than ED
  let asset: MultiAsset = (asset_multilocation, amount_bought).into();
- assert_noop!(trader.buy_weight(bought, asset.into()), XcmError::TooExpensive);
+ assert_noop!(
+ trader.buy_weight(&XcmContext::with_message_id([0; 32]), bought, asset.into()),
+ XcmError::TooExpensive
+ );
 
  // Now lets buy ED at least
  let asset: MultiAsset = (asset_multilocation, ExistentialDeposit::get()).into();
 
  // Buy weight should work
- assert_ok!(trader.buy_weight(bought, asset.into()));
+ assert_ok!(trader.buy_weight(
+ &XcmContext::with_message_id([0; 32]),
+ bought,
+ asset.into()
+ ));
 
  // Should return None. We have a specific check making sure we dont go below ED for
  // drop payment
- assert_eq!(trader.refund_weight(bought), None);
+ assert_eq!(trader.refund_weight(&XcmContext::with_message_id([0; 32]), bought), None);
 
  // Drop trader
  drop(trader);
@@ -384,7 +399,10 @@ fn test_asset_xcm_trader_not_possible_for_non_sufficient_assets() {
  let asset: MultiAsset = (asset_multilocation, asset_amount_needed).into();
 
  // Make sure again buy_weight does return an error
- assert_noop!(trader.buy_weight(bought, asset.into()), XcmError::TooExpensive);
+ assert_noop!(
+ trader.buy_weight(&XcmContext::with_message_id([0; 32]), bought, asset.into()),
+ XcmError::TooExpensive
+ );
 
  // Drop trader
  drop(trader);

parachains/runtimes/assets/asset-hub-westend/src/lib.rs

@@ -1224,6 +1224,7 @@ impl_runtime_apis! {
  Ok(WestendLocation::get())
  }
  fn worst_case_holding(depositable_count: u32) -> MultiAssets {
+
  // A mix of fungible, non-fungible, and concrete assets.
  let holding_non_fungibles = MaxAssetsIntoHolding::get() / 2 - depositable_count;
  let holding_fungibles = holding_non_fungibles - 1;

parachains/runtimes/assets/asset-hub-westend/src/xcm_config.rs

@@ -24,6 +24,7 @@ use assets_common::{
  matching::{
  FromSiblingParachain, IsForeignConcreteAsset, StartsWith, StartsWithExplicitGlobalConsensus,
  },
+ AssetIdForTrustBackedAssetsConvert,
 };
 use frame_support::{
  match_types, parameter_types,
@@ -46,6 +47,7 @@ use xcm_builder::{
 };
 use xcm_executor::{traits::WithOriginFilter, XcmExecutor};
 
+use assets_common::local_and_foreign_assets::LocalAndForeignAssets;
 #[cfg(feature = "runtime-benchmarks")]
 use {cumulus_primitives_core::ParaId, sp_core::Get};
 
@@ -125,6 +127,17 @@ pub type ForeignAssetsConvertedConcreteId = assets_common::ForeignAssetsConverte
  Balance,
 >;
 
+/// `AssetId/Balance` converter for pay by swap
+pub type LocalAndForeignAssetsConvertedConcreteId = assets_common::ForeignAssetsConvertedConcreteId<
+ (
+ // Ignore asset which starts explicitly with our `GlobalConsensus(NetworkId)`, means:
+ // - foreign assets from our consensus should be: `MultiLocation {parents: 1, X*(Parachain(xyz), ..)}
+ // - foreign assets outside our consensus with the same `GlobalConsensus(NetworkId)` wont be accepted here
+ StartsWithExplicitGlobalConsensus<UniversalLocationNetworkId>,
+ ),
+ Balance,
+>;
+
 /// Means for transacting foreign assets from different global consensus.
 pub type ForeignFungiblesTransactor = FungiblesAdapter<
  // Use this fungibles implementation:
@@ -469,12 +482,19 @@ impl xcm_executor::Config for XcmConfig {
  >;
  type Trader = (
  UsingComponents<WeightToFee, WestendLocation, AccountId, Balances, ToStakingPot<Runtime>>,
- cumulus_primitives_utility::TakeFirstAssetTrader<
- AccountId,
- AssetFeeAsExistentialDepositMultiplierFeeCharger,
- TrustBackedAssetsConvertedConcreteId,
- Assets,
+ cumulus_primitives_utility::SwapFirstAssetTrader<
+ Runtime,
+ LocationToAccountId,
+ pallet_asset_conversion::Pallet<Runtime>,
+ WeightToFee,
+ LocalAndForeignAssetsConvertedConcreteId,
+ LocalAndForeignAssets<
+ Assets,
+ AssetIdForTrustBackedAssetsConvert<TrustBackedAssetsPalletLocation>,
+ ForeignAssets,
+ >,
  cumulus_primitives_utility::XcmFeesTo32ByteAccount<
+ // Revenue could also be Foreign Fungible? Maybe with multi-asset treasury..?
  FungiblesTransactor,
  AccountId,
  XcmAssetFeesReceiver,

primitives/utility/Cargo.toml

@@ -10,6 +10,7 @@ log = { version = "0.4.19", default-features = false }
 
 # Substrate
 frame-support = { git = "https://github.com/paritytech/substrate", default-features = false, branch = "master" }
+pallet-asset-conversion = { git = "https://github.com/paritytech/substrate", default-features = false, branch = "master" }
 sp-io = { git = "https://github.com/paritytech/substrate", default-features = false, branch = "master" }
 sp-runtime = { git = "https://github.com/paritytech/substrate", default-features = false, branch = "master" }
 sp-std = { git = "https://github.com/paritytech/substrate", default-features = false, branch = "master" }
@@ -29,6 +30,7 @@ default = [ "std" ]
 std = [
  "codec/std",
  "frame-support/std",
+ "pallet-asset-conversion/std",
  "sp-runtime/std",
  "sp-std/std",
  "sp-io/std",

primitives/utility/src/lib.rs

@@ -28,12 +28,16 @@ use frame_support::{
  },
  weights::Weight,
 };
+use pallet_asset_conversion::{Config, MultiAssetIdConverter, Swap};
 use polkadot_runtime_common::xcm_sender::ConstantPrice;
-use sp_runtime::{traits::Saturating, SaturatedConversion};
+use sp_runtime::{
+ traits::{CheckedSub, Saturating},
+ SaturatedConversion,
+};
 use sp_std::{marker::PhantomData, prelude::*};
 use xcm::{latest::prelude::*, WrapVersion};
 use xcm_builder::TakeRevenue;
-use xcm_executor::traits::{MatchesFungibles, TransactAsset, WeightTrader};
+use xcm_executor::traits::{ConvertLocation, MatchesFungibles, TransactAsset, WeightTrader};
 
 pub trait PriceForParentDelivery {
  fn price_for_parent_delivery(message: &Xcm<()>) -> MultiAssets;
@@ -144,6 +148,7 @@ impl<
  // If everything goes well, we charge.
  fn buy_weight(
  &mut self,
+ _: &XcmContext,
  weight: Weight,
  payment: xcm_executor::Assets,
  ) -> Result<xcm_executor::Assets, XcmError> {
@@ -196,7 +201,7 @@ impl<
  Ok(unused)
  }
 
- fn refund_weight(&mut self, weight: Weight) -> Option<MultiAsset> {
+ fn refund_weight(&mut self, _ctx: &XcmContext, weight: Weight) -> Option<MultiAsset> {
  log::trace!(target: "xcm::weight", "TakeFirstAssetTrader::refund_weight weight: {:?}", weight);
  if let Some(AssetTraderRefunder {
  mut weight_outstanding,
@@ -269,8 +274,150 @@ impl<
  }
 }
 
+/// Contains information to handle refund/payment for xcm-execution
+#[derive(Clone, Eq, PartialEq, Debug)]
+struct SwapAssetTraderRefunder {
+ // The concrete asset containing the asset location and any leftover balance
+ outstanding_concrete_asset: MultiAsset,
+}
+
+pub struct SwapFirstAssetTrader<
+ T: Config,
+ AccountIdConverter: ConvertLocation<T::AccountId>,
+ SWP: Swap<T::AccountId, T::HigherPrecisionBalance, T::MultiAssetId>,
+ WeightToFee: frame_support::weights::WeightToFee<Balance = T::Balance>,
+ Matcher: MatchesFungibles<ConcreteAssets::AssetId, ConcreteAssets::Balance>,
+ ConcreteAssets: fungibles::Mutate<T::AccountId> + fungibles::Balanced<T::AccountId>,
+ HandleRefund: TakeRevenue,
+>(
+ Option<SwapAssetTraderRefunder>,
+ PhantomData<(T, AccountIdConverter, SWP, WeightToFee, Matcher, ConcreteAssets, HandleRefund)>,
+);
+
+impl<
+ T: Config,
+ AccountIdConverter: ConvertLocation<T::AccountId>,
+ SWP: Swap<T::AccountId, T::HigherPrecisionBalance, T::MultiAssetId>,
+ WeightToFee: frame_support::weights::WeightToFee<Balance = T::Balance>,
+ Matcher: MatchesFungibles<ConcreteAssets::AssetId, ConcreteAssets::Balance>,
+ ConcreteAssets: fungibles::Mutate<T::AccountId> + fungibles::Balanced<T::AccountId>,
+ HandleRefund: TakeRevenue,
+ > WeightTrader
+ for SwapFirstAssetTrader<
+ T,
+ AccountIdConverter,
+ SWP,
+ WeightToFee,
+ Matcher,
+ ConcreteAssets,
+ HandleRefund,
+ > where
+ T::HigherPrecisionBalance: From<ConcreteAssets::Balance> + TryInto<T::AssetBalance>,
+ <T::HigherPrecisionBalance as TryInto<T::AssetBalance>>::Error: core::fmt::Debug,
+ T::AssetBalance: Into<Fungibility>,
+ MultiLocation: From<ConcreteAssets::AssetId> + Into<T::MultiAssetId>,
+{
+ fn new() -> Self {
+ Self(None, PhantomData)
+ }
+
+ // We take the first multiasset present in the payment
+ // Check whether we can swap the payment tokens using asset_conversion pallet
+ // If swap can be applied, we execute it
+ // On successful swap, we substract from the payment
+ fn buy_weight(
+ &mut self,
+ ctx: &XcmContext,
+ weight: Weight,
+ payment: xcm_executor::Assets,
+ ) -> Result<xcm_executor::Assets, XcmError> {
+ log::trace!(target: "xcm::weight", "SwapFirstAssetTrader::buy_weight weight: {:?}, payment: {:?}", weight, payment);
+
+ // Make sure we dont enter twice
+ if self.0.is_some() {
+ return Err(XcmError::NotWithdrawable)
+ }
+
+ // We take the very first multiasset from payment
+ // (assets are sorted by fungibility/amount after this conversion)
+ let multiassets: MultiAssets = payment.clone().into();
+
+ // Take the first multiasset from the selected MultiAssets
+ let first = multiassets.get(0).ok_or(XcmError::AssetNotFound)?;
+
+ // Get the asset id in which we can pay for fees
+ let (asset_id, local_asset_balance) =
+ Matcher::matches_fungibles(first).map_err(|_| XcmError::AssetNotFound)?;
+
+ let asset_loc: MultiLocation = asset_id.into();
+
+ let fee = WeightToFee::weight_to_fee(&weight);
+
+ let origin = ctx.origin.ok_or(XcmError::BadOrigin)?;
+ let acc = AccountIdConverter::convert_location(&origin).ok_or(XcmError::InvalidLocation)?;
+
+ let amount_taken = SWP::swap_tokens_for_exact_tokens(
+ acc.clone(),
+ vec![asset_loc.into(), T::MultiAssetIdConverter::get_native()],
+ fee.into(),
+ None,
+ acc.clone(),
+ true,
+ )
+ .map_err(|_| XcmError::AssetNotFound)?;
+
+ // Substract amount_taken from payment_balance
+ let unused = T::HigherPrecisionBalance::from(local_asset_balance)
+ .checked_sub(&amount_taken)
+ .ok_or(XcmError::TooExpensive)?;
+
+ let unused_balance: T::AssetBalance = unused.try_into().map_err(|_| XcmError::Overflow)?;
+
+ // Record outstanding asset
+ self.0 = Some(SwapAssetTraderRefunder { outstanding_concrete_asset: first.clone() });
+
+ Ok(first.id.into_multiasset(unused_balance.into()).into())
+ }
+
+ fn refund_weight(&mut self, ctx: &XcmContext, weight: Weight) -> Option<MultiAsset> {
+ log::trace!(target: "xcm::weight", "SwapFirstAssetTrader::refund_weight weight: {:?}", weight);
+
+ // TODO: swap back the weight with swap_exact_tokens_for_tokens
+
+ None
+ }
+}
+
+impl<
+ T: Config,
+ AccountIdConverter: ConvertLocation<T::AccountId>,
+ SWP: Swap<T::AccountId, T::HigherPrecisionBalance, T::MultiAssetId>,
+ WeightToFee: frame_support::weights::WeightToFee<Balance = T::Balance>,
+ Matcher: MatchesFungibles<ConcreteAssets::AssetId, ConcreteAssets::Balance>,
+ ConcreteAssets: fungibles::Mutate<T::AccountId> + fungibles::Balanced<T::AccountId>,
+ HandleRefund: TakeRevenue,
+ > Drop
+ for SwapFirstAssetTrader<
+ T,
+ AccountIdConverter,
+ SWP,
+ WeightToFee,
+ Matcher,
+ ConcreteAssets,
+ HandleRefund,
+ >
+{
+ fn drop(&mut self) {
+ if let Some(asset_trader) = self.0.clone() {
+ HandleRefund::take_revenue(asset_trader.outstanding_concrete_asset);
+ }
+ }
+}
+
 /// XCM fee depositor to which we implement the TakeRevenue trait
-/// It receives a Transact implemented argument, a 32 byte convertible acocuntId, and the fee receiver account
+/// It receives a Transact implemented argument, a 32 byte convertible accountId,
+/// and the fee receiver account
+///
 /// FungiblesMutateAdapter should be identical to that implemented by WithdrawAsset
 pub struct XcmFeesTo32ByteAccount<FungiblesMutateAdapter, AccountId, ReceiverAccount>(
  PhantomData<(FungiblesMutateAdapter, AccountId, ReceiverAccount)>,
@@ -533,9 +680,16 @@ mod tests {
  let weight_to_buy = Weight::from_parts(1_000, 1_000);
 
  // lets do first call (success)
- assert_ok!(trader.buy_weight(weight_to_buy, payment.clone()));
+ assert_ok!(trader.buy_weight(
+ &XcmContext::with_message_id([0; 32]),
+ weight_to_buy,
+ payment.clone()
+ ));
 
  // lets do second call (error)
- assert_eq!(trader.buy_weight(weight_to_buy, payment), Err(XcmError::NotWithdrawable));
+ assert_eq!(
+ trader.buy_weight(&XcmContext::with_message_id([0; 32]), weight_to_buy, payment),
+ Err(XcmError::NotWithdrawable)
+ );
  }
 }