393 use fee per second from asset metadata in xcm config

node/src/chain_spec.rs

@@ -537,8 +537,9 @@ fn foucoco_genesis(
 
 	let token_balances = balances
 		.iter()
-		.flat_map(|k| vec![(k.0.clone(), XCM(0), u128::pow(10, 18))])
+		.flat_map(|k| vec![(k.0.clone(), XCM(0), 10*u128::pow(10, 18)), (k.0.clone(), XCM(6), 10*u128::pow(10, 18)), (k.0.clone(), CurrencyId::StellarNative, 10*u128::pow(10, 18))])
 		.collect();
+
 
 	let stakers: Vec<_> = invulnerables
 		.iter()

node/src/constants/foucoco.rs

@@ -10,6 +10,7 @@ pub const COLLATOR_ADDITIONAL: Balance = 10 * UNIT;
 
 pub const OFF_CHAIN_WORKER_ADDRESS: &str = "6m69vWMouLarYCbJGJisVaDDpfNGETkD5hsDWf2T7osW4Cn1";
 
+
 pub const TOKEN_DECIMALS: u32 = 12;
 
 pub const INITIAL_SUDO_SIGNATORIES: [&str; 5] = [

runtime/amplitude/src/xcm_config.rs

@@ -1,12 +1,10 @@
 use core::marker::PhantomData;
 
 use frame_support::{
-	log, match_types,
-	pallet_prelude::DispatchError,
-	parameter_types,
-	traits::{tokens::fungibles, ContainsPair, Everything, Nothing, ProcessMessageError},
-	weights::{Weight, WeightToFee as WeightToFeeTrait},
+	log, match_types, parameter_types,
+	traits::{ContainsPair, Everything, Nothing, ProcessMessageError},
 };
+use orml_asset_registry::{AssetRegistryTrader, FixedRateAssetRegistryTrader};
 use orml_traits::{
 	location::{RelativeReserveProvider, Reserve},
 	parameter_type_with_key,
@@ -18,35 +16,22 @@ use sp_runtime::traits::Convert;
 use xcm::latest::{prelude::*, Weight as XCMWeight};
 use xcm_builder::{
 	AccountId32Aliases, AllowKnownQueryResponses, AllowSubscriptionsFrom,
-	AllowTopLevelPaidExecutionFrom, AllowUnpaidExecutionFrom, ConvertedConcreteId, EnsureXcmOrigin,
-	FixedWeightBounds, ParentIsPreset, RelayChainAsNative, SiblingParachainAsNative,
-	SiblingParachainConvertsVia, SignedAccountId32AsNative, SignedToAccountId32,
-	SovereignSignedViaLocation, TakeWeightCredit,
-};
-use xcm_executor::{
-	traits::{JustTry, ShouldExecute},
-	XcmExecutor,
+	AllowTopLevelPaidExecutionFrom, AllowUnpaidExecutionFrom, EnsureXcmOrigin, FixedWeightBounds,
+	ParentIsPreset, RelayChainAsNative, SiblingParachainAsNative, SiblingParachainConvertsVia,
+	SignedAccountId32AsNative, SignedToAccountId32, SovereignSignedViaLocation, TakeWeightCredit,
 };
+use xcm_executor::{traits::ShouldExecute, XcmExecutor};
 
-use runtime_common::{parachains::kusama::asset_hub, RelativeValue};
+use runtime_common::{asset_registry::FixedConversionRateProvider};
 
-use cumulus_primitives_utility::{
-	ChargeWeightInFungibles, TakeFirstAssetTrader, XcmFeesTo32ByteAccount,
-};
-use sp_runtime::traits::Zero;
-
-use crate::{
-	assets::{
-		native_locations::{native_location_external_pov, native_location_local_pov},
-		xcm_assets,
-	},
-	ConstU32,
-};
+use cumulus_primitives_utility::XcmFeesTo32ByteAccount;
+
+use crate::ConstU32;
 
 use super::{
-	AccountId, AmplitudeTreasuryAccount, Balance, Balances, Currencies, CurrencyId, ParachainInfo,
-	ParachainSystem, PolkadotXcm, Runtime, RuntimeCall, RuntimeEvent, RuntimeOrigin, Tokens,
-	WeightToFee, XcmpQueue,
+	AccountId, AmplitudeTreasuryAccount, AssetRegistry, Balance, Balances, Currencies, CurrencyId,
+	ParachainInfo, ParachainSystem, PolkadotXcm, Runtime, RuntimeCall, RuntimeEvent, RuntimeOrigin,
+	XcmpQueue,
 };
 use frame_system::EnsureRoot;
 
@@ -80,30 +65,32 @@ pub struct CurrencyIdConvert;
 
 impl Convert<CurrencyId, Option<MultiLocation>> for CurrencyIdConvert {
 	fn convert(id: CurrencyId) -> Option<MultiLocation> {
-		match id {
-			CurrencyId::XCM(index) => match index {
-				xcm_assets::RELAY_KSM => Some(MultiLocation::parent()),
-				xcm_assets::ASSETHUB_USDT => Some(asset_hub::USDT_location()),
-				_ => None,
-			},
-			CurrencyId::Native => Some(native_location_external_pov()),
-			_ => None,
-		}
+		AssetRegistry::metadata(&id)
+			.filter(|m| m.location.is_some())
+			.and_then(|m| m.location)
+			.and_then(|l| l.try_into().ok())
 	}
 }
 
 impl Convert<MultiLocation, Option<CurrencyId>> for CurrencyIdConvert {
-	fn convert(location: MultiLocation) -> Option<CurrencyId> {
-		match location {
-			loc if loc == MultiLocation::parent() => Some(xcm_assets::RELAY_KSM_id()),
-			loc if loc == asset_hub::USDT_location() => Some(xcm_assets::ASSETHUB_USDT_id()),
-			// Our native currency location without re-anchoring
-			loc if loc == native_location_external_pov() => Some(CurrencyId::Native),
-			// Our native currency location with re-anchoring
-			// The XCM pallet will try to re-anchor the location before it reaches here
-			loc if loc == native_location_local_pov() => Some(CurrencyId::Native),
-			_ => None,
-		}
+	fn convert(location: MultiLocation) -> Option<CurrencyId>  {
+		let para_id = ParachainInfo::parachain_id();
+		let unanchored_location = match location {
+            MultiLocation { parents: 0, interior } => {
+
+                match interior.pushed_front_with(Parachain(u32::from(para_id))) {
+                    Ok(new_interior) => MultiLocation {
+                        parents: 1,
+                        interior: new_interior,
+                    },
+                    Err(_) => return None, 
+                }
+            },
+
+            x => x,
+        };
+
+		AssetRegistry::location_to_asset_id(unanchored_location)
 	}
 }
 
@@ -117,23 +104,6 @@ impl Convert<MultiAsset, Option<CurrencyId>> for CurrencyIdConvert {
 	}
 }
 
-type RelativeValueOf = RelativeValue<Balance>;
-
-pub struct RelayRelativeValue;
-impl RelayRelativeValue {
-	fn get_relative_value(id: CurrencyId) -> Option<RelativeValueOf> {
-		match id {
-			CurrencyId::XCM(index) => match index {
-				xcm_assets::RELAY_KSM => Some(RelativeValueOf { num: 100, denominator: 1 }),
-				xcm_assets::ASSETHUB_USDT => Some(RelativeValueOf { num: 20, denominator: 4 }),
-				_ => None,
-			},
-			CurrencyId::Native => Some(RelativeValueOf { num: 1, denominator: 1 }),
-			_ => Some(RelativeValueOf { num: 1, denominator: 1 }),
-		}
-	}
-}
-
 /// Convert an incoming `MultiLocation` into a `CurrencyId` if possible.
 /// Here we need to know the canonical representation of all the tokens we handle in order to
 /// correctly convert their `MultiLocation` representation into our internal `CurrencyId` type.
@@ -204,13 +174,6 @@ parameter_types! {
 	pub const MaxAssetsForTransfer: usize = 2;
 }
 
-match_types! {
-	pub type ParentOrParentsExecutivePlurality: impl Contains<MultiLocation> = {
-		MultiLocation { parents: 1, interior: Here } |
-		MultiLocation { parents: 1, interior: X1(Plurality { id: BodyId::Executive, .. }) }
-	};
-}
-
 //TODO: move DenyThenTry to polkadot's xcm module.
 /// Deny executing the xcm message if it matches any of the Deny filter regardless of anything else.
 /// If it passes the Deny, and matches one of the Allow cases then it is let through.
@@ -292,114 +255,10 @@ pub type Barrier = (
 	AllowSubscriptionsFrom<Everything>,
 );
 
-pub struct ChargeWeightInFungiblesImplementation;
-impl ChargeWeightInFungibles<AccountId, ConcreteAssets> for ChargeWeightInFungiblesImplementation {
-	fn charge_weight_in_fungibles(
-		asset_id: CurrencyId,
-		weight: Weight,
-	) -> Result<Balance, XcmError> {
-		let amount = <WeightToFee as WeightToFeeTrait>::weight_to_fee(&weight);
-
-		if let Some(relative_value) = RelayRelativeValue::get_relative_value(asset_id) {
-			let adjusted_amount =
-				RelativeValue::<Balance>::divide_by_relative_value(amount, relative_value);
-			log::info!("amount to be charged: {:?} in asset: {:?}", adjusted_amount, asset_id);
-			return Ok(adjusted_amount)
-		} else {
-			log::info!("amount to be charged: {:?} in asset: {:?}", amount, asset_id);
-			return Ok(amount)
-		}
-	}
-}
-
-// Workarround for TakeFirstAssetTrader
-use frame_support::traits::tokens::{
-	DepositConsequence, Fortitude, Preservation, Provenance, WithdrawConsequence,
-};
-
-pub struct ConcreteAssets;
-impl fungibles::Mutate<AccountId> for ConcreteAssets {}
-impl fungibles::Balanced<AccountId> for ConcreteAssets {
-	type OnDropCredit = fungibles::DecreaseIssuance<AccountId, Self>;
-	type OnDropDebt = fungibles::IncreaseIssuance<AccountId, Self>;
-}
-// We only use minimum_balance of these implementations
-impl fungibles::Inspect<AccountId> for ConcreteAssets {
-	type AssetId = <Tokens as fungibles::Inspect<AccountId>>::AssetId;
-	type Balance = <Tokens as fungibles::Inspect<AccountId>>::Balance;
-
-	fn minimum_balance(id: Self::AssetId) -> Self::Balance {
-		Tokens::minimum_balance(id)
-	}
-
-	fn total_issuance(asset_id: Self::AssetId) -> Self::Balance {
-		Tokens::total_issuance(asset_id)
-	}
-
-	fn balance(asset_id: Self::AssetId, account_id: &AccountId) -> Self::Balance {
-		Tokens::balance(asset_id, account_id)
-	}
-
-	fn total_balance(asset_id: Self::AssetId, account_id: &AccountId) -> Self::Balance {
-		Tokens::balance(asset_id, account_id)
-	}
-
-	fn reducible_balance(
-		_: Self::AssetId,
-		_: &AccountId,
-		_: Preservation,
-		_: Fortitude,
-	) -> Self::Balance {
-		Self::Balance::zero()
-	}
-
-	fn can_deposit(
-		_: Self::AssetId,
-		_: &AccountId,
-		_: Self::Balance,
-		_: Provenance,
-	) -> DepositConsequence {
-		DepositConsequence::UnknownAsset
-	}
-
-	fn can_withdraw(
-		_: Self::AssetId,
-		_: &AccountId,
-		_: Self::Balance,
-	) -> WithdrawConsequence<Self::Balance> {
-		WithdrawConsequence::UnknownAsset
-	}
-
-	fn asset_exists(_: Self::AssetId) -> bool {
-		false
-	}
-}
-
-// Not used
-impl fungibles::Unbalanced<AccountId> for ConcreteAssets {
-	fn handle_dust(_: fungibles::Dust<AccountId, Self>) {
-	}
-	fn write_balance(
-		_: Self::AssetId,
-		_: &AccountId,
-		_: Self::Balance,
-	) -> Result<Option<Self::Balance>, DispatchError> {
-		core::prelude::v1::Err(DispatchError::CannotLookup)
-	}
-
-	fn set_total_issuance(_: Self::AssetId, _: Self::Balance) {
-	}
-}
-
-pub type Traders = (
-	TakeFirstAssetTrader<
-		AccountId,
-		ChargeWeightInFungiblesImplementation,
-		ConvertedConcreteId<CurrencyId, Balance, CurrencyIdConvert, JustTry>,
-		ConcreteAssets,
-		XcmFeesTo32ByteAccount<LocalAssetTransactor, AccountId, AmplitudeTreasuryAccount>,
-	>,
-);
+pub type Traders = AssetRegistryTrader<
+	FixedRateAssetRegistryTrader<FixedConversionRateProvider<AssetRegistry, CurrencyIdConvert>>,
+	XcmFeesTo32ByteAccount<LocalAssetTransactor, AccountId, AmplitudeTreasuryAccount>,
+>;
 
 pub struct XcmConfig;
 impl xcm_executor::Config for XcmConfig {

runtime/common/Cargo.toml

@@ -14,6 +14,7 @@ targets = ["x86_64-unknown-linux-gnu"]
 paste = "1.0.14"
 parity-scale-codec = { version = "3.1.5", default-features = false, features = ["derive"] }
 scale-info = { version = "2.1.1", default-features = false, features = ["derive"] }
+log = { version = "0.4.17", default-features = false }
 
 frame-support = { git = "https://github.com/paritytech/substrate", default-features = false, branch = "polkadot-v0.9.42" }
 frame-benchmarking = { git = "https://github.com/paritytech/substrate", branch = "polkadot-v0.9.42", default-features = false, optional = true }
@@ -41,6 +42,7 @@ default = [
 ]
 
 std = [
+    "log/std",
     "parity-scale-codec/std",
     "scale-info/std",
     "frame-benchmarking?/std",

runtime/common/src/asset_registry.rs

@@ -1,16 +1,18 @@
 use crate::*;
 use frame_support::traits::AsEnsureOriginWithArg;
 use frame_system::EnsureRoot;
-use orml_traits::asset_registry::{AssetMetadata, AssetProcessor};
+use orml_traits::{FixedConversionRateProvider as FixedConversionRateProviderTrait,
+	asset_registry::{AssetMetadata, AssetProcessor, Inspect}};
 use parity_scale_codec::{Decode, Encode, MaxEncodedLen};
 use scale_info::TypeInfo;
 use sp_core::Get;
-use sp_runtime::{BoundedVec, DispatchError};
+use sp_runtime::{BoundedVec, DispatchError, traits::{PhantomData, Convert}};
 use sp_std::fmt::Debug;
 use spacewalk_primitives::CurrencyId;
+use xcm::opaque::v3::{MultiLocation};
 
 #[derive(Clone, PartialOrd, Ord, PartialEq, Eq, Debug, Encode, Decode, TypeInfo, MaxEncodedLen)]
-pub struct StringLimit; 
+pub struct StringLimit;
 impl Get<u32> for StringLimit {
 	fn get() -> u32 {
 		50
@@ -54,3 +56,24 @@ impl AssetProcessor<CurrencyId, AssetMetadata<Balance, CustomMetadata>> for Cust
 }
 
 pub type AssetAuthority = AsEnsureOriginWithArg<EnsureRoot<AccountId>>;
+pub struct FixedConversionRateProvider<OrmlAssetRegistry, CurrencyIdConvert>(PhantomData<(OrmlAssetRegistry,CurrencyIdConvert)>);
+
+impl<
+		OrmlAssetRegistry: Inspect<
+			AssetId = CurrencyId,
+			Balance = Balance,
+			CustomMetadata = asset_registry::CustomMetadata,
+		>,
+		CurrencyIdConvert: Convert<MultiLocation, Option<CurrencyId>>,
+	> FixedConversionRateProviderTrait for FixedConversionRateProvider<OrmlAssetRegistry, CurrencyIdConvert>
+{
+	fn get_fee_per_second(location: &MultiLocation) -> Option<u128> {
+		let asset_id_maybe = CurrencyIdConvert::convert(location.clone());
+		let asset_id = match asset_id_maybe {
+			Some(id) => id,
+			None => return None,
+		};
+		let metadata = OrmlAssetRegistry::metadata(&asset_id)?;
+		Some(metadata.additional.fee_per_second)
+	}
+}

runtime/common/src/benchmarking/orml_asset_registry.rs

@@ -1,7 +1,9 @@
+use crate::asset_registry::{CustomMetadata, DiaKeys};
 use frame_benchmarking::v2::benchmarks;
 use frame_support::assert_ok;
 use frame_system::RawOrigin;
 use orml_asset_registry::AssetMetadata;
+use sp_runtime::BoundedVec;
 use sp_std::{vec, vec::Vec};
 use spacewalk_primitives::CurrencyId;
 use xcm::{