git.delta.rocks / unique-network / refs/commits / 9581cf6201ab

82    cd /polkadot-launch && \82    cd /polkadot-launch && \
83    yarn start launch-config-xcm-{{ NETWORK }}.json83    yarn start launch-config-xcm-{{ NETWORK }}.json
8484
85
8685

5149 "frame-try-runtime",5149 "frame-try-runtime",
5150 "hex-literal",5150 "hex-literal",
5151 "log",5151 "log",
5152 "orml-tokens",
5153 "orml-traits",
5152 "orml-vesting",5154 "orml-vesting",
5155 "orml-xtokens",
5153 "pallet-aura",5156 "pallet-aura",
5154 "pallet-balances",5157 "pallet-balances",
5155 "pallet-base-fee",5158 "pallet-base-fee",
5161 "pallet-evm-contract-helpers",5164 "pallet-evm-contract-helpers",
5162 "pallet-evm-migration",5165 "pallet-evm-migration",
5163 "pallet-evm-transaction-payment",5166 "pallet-evm-transaction-payment",
5167 "pallet-foreing-assets",
5164 "pallet-fungible",5168 "pallet-fungible",
5165 "pallet-inflation",5169 "pallet-inflation",
5166 "pallet-nonfungible",5170 "pallet-nonfungible",
5265 "num-traits",5269 "num-traits",
5266]5270]
5271
5272[[package]]
5273name = "orml-tokens"
5274version = "0.4.1-dev"
5275source = "git+https://github.com/open-web3-stack/open-runtime-module-library?branch=polkadot-v0.9.27#377213f750755cc48e80a3131eaae63b5eda8362"
5276dependencies = [
5277 "frame-support",
5278 "frame-system",
5279 "orml-traits",
5280 "parity-scale-codec 3.1.5",
5281 "scale-info",
5282 "serde",
5283 "sp-runtime",
5284 "sp-std",
5285]
5286
5287[[package]]
5288name = "orml-traits"
5289version = "0.4.1-dev"
5290source = "git+https://github.com/open-web3-stack/open-runtime-module-library?branch=polkadot-v0.9.27#377213f750755cc48e80a3131eaae63b5eda8362"
5291dependencies = [
5292 "frame-support",
5293 "impl-trait-for-tuples",
5294 "num-traits",
5295 "orml-utilities",
5296 "parity-scale-codec 3.1.5",
5297 "scale-info",
5298 "serde",
5299 "sp-io",
5300 "sp-runtime",
5301 "sp-std",
5302 "xcm",
5303]
5304
5305[[package]]
5306name = "orml-utilities"
5307version = "0.4.1-dev"
5308source = "git+https://github.com/open-web3-stack/open-runtime-module-library?branch=polkadot-v0.9.27#377213f750755cc48e80a3131eaae63b5eda8362"
5309dependencies = [
5310 "frame-support",
5311 "parity-scale-codec 3.1.5",
5312 "scale-info",
5313 "serde",
5314 "sp-io",
5315 "sp-runtime",
5316 "sp-std",
5317]
52675318
5268[[package]]5319[[package]]
5269name = "orml-vesting"5320name = "orml-vesting"
5280 "sp-std",5331 "sp-std",
5281]5332]
5333
5334[[package]]
5335name = "orml-xcm-support"
5336version = "0.4.1-dev"
5337source = "git+https://github.com/open-web3-stack/open-runtime-module-library?branch=polkadot-v0.9.27#377213f750755cc48e80a3131eaae63b5eda8362"
5338dependencies = [
5339 "frame-support",
5340 "orml-traits",
5341 "parity-scale-codec 3.1.5",
5342 "sp-runtime",
5343 "sp-std",
5344 "xcm",
5345 "xcm-executor",
5346]
5347
5348[[package]]
5349name = "orml-xtokens"
5350version = "0.4.1-dev"
5351source = "git+https://github.com/open-web3-stack/open-runtime-module-library?branch=polkadot-v0.9.27#377213f750755cc48e80a3131eaae63b5eda8362"
5352dependencies = [
5353 "cumulus-primitives-core",
5354 "frame-support",
5355 "frame-system",
5356 "orml-traits",
5357 "orml-xcm-support",
5358 "pallet-xcm",
5359 "parity-scale-codec 3.1.5",
5360 "scale-info",
5361 "serde",
5362 "sp-io",
5363 "sp-runtime",
5364 "sp-std",
5365 "xcm",
5366 "xcm-executor",
5367]
52825368
5283[[package]]5369[[package]]
5284name = "os_str_bytes"5370name = "os_str_bytes"
5747 "up-sponsorship",5833 "up-sponsorship",
5748]5834]
5835
5836[[package]]
5837name = "pallet-foreing-assets"
5838version = "0.1.0"
5839dependencies = [
5840 "frame-support",
5841 "frame-system",
5842 "hex",
5843 "log",
5844 "orml-tokens",
5845 "pallet-balances",
5846 "pallet-common",
5847 "pallet-fungible",
5848 "pallet-timestamp",
5849 "parity-scale-codec 3.1.5",
5850 "scale-info",
5851 "serde",
5852 "serde_json",
5853 "sp-core",
5854 "sp-io",
5855 "sp-runtime",
5856 "sp-std",
5857 "up-data-structs",
5858 "xcm",
5859 "xcm-builder",
5860 "xcm-executor",
5861]
57495862
5750[[package]]5863[[package]]
5751name = "pallet-fungible"5864name = "pallet-fungible"
8354 "frame-try-runtime",8467 "frame-try-runtime",
8355 "hex-literal",8468 "hex-literal",
8356 "log",8469 "log",
8470 "orml-tokens",
8471 "orml-traits",
8357 "orml-vesting",8472 "orml-vesting",
8473 "orml-xtokens",
8358 "pallet-aura",8474 "pallet-aura",
8359 "pallet-balances",8475 "pallet-balances",
8360 "pallet-base-fee",8476 "pallet-base-fee",
8366 "pallet-evm-contract-helpers",8482 "pallet-evm-contract-helpers",
8367 "pallet-evm-migration",8483 "pallet-evm-migration",
8368 "pallet-evm-transaction-payment",8484 "pallet-evm-transaction-payment",
8485 "pallet-foreing-assets",
8369 "pallet-fungible",8486 "pallet-fungible",
8370 "pallet-inflation",8487 "pallet-inflation",
8371 "pallet-nonfungible",8488 "pallet-nonfungible",
12343 "frame-try-runtime",12460 "frame-try-runtime",
12344 "hex-literal",12461 "hex-literal",
12345 "log",12462 "log",
12463 "orml-tokens",
12464 "orml-traits",
12346 "orml-vesting",12465 "orml-vesting",
12466 "orml-xtokens",
12347 "pallet-aura",12467 "pallet-aura",
12348 "pallet-balances",12468 "pallet-balances",
12349 "pallet-base-fee",12469 "pallet-base-fee",
12355 "pallet-evm-contract-helpers",12475 "pallet-evm-contract-helpers",
12356 "pallet-evm-migration",12476 "pallet-evm-migration",
12357 "pallet-evm-transaction-payment",12477 "pallet-evm-transaction-payment",
12478 "pallet-foreing-assets",
12358 "pallet-fungible",12479 "pallet-fungible",
12359 "pallet-inflation",12480 "pallet-inflation",
12360 "pallet-nonfungible",12481 "pallet-nonfungible",

65	Unknown(String),65	Unknown(String),
66}66}
67
68#[cfg(not(feature = "unique-runtime"))]
69/// PARA_ID for Opal/Quartz
70const PARA_ID: u32 = 2095;
71
72#[cfg(feature = "unique-runtime")]
73/// PARA_ID for Unique
74const PARA_ID: u32 = 2037;
6775
68pub trait RuntimeIdentification {76pub trait RuntimeIdentification {
69	fn runtime_id(&self) -> RuntimeId;77	fn runtime_id(&self) -> RuntimeId;
167					.collect(),175					.collect(),
168			},176			},
169			treasury: Default::default(),177			treasury: Default::default(),
178			tokens: TokensConfig { balances: vec![] },
170			sudo: SudoConfig {179			sudo: SudoConfig {
171				key: Some($root_key),180				key: Some($root_key),
172			},181			},
235					get_account_id_from_seed::<sr25519::Public>("Eve//stash"),244					get_account_id_from_seed::<sr25519::Public>("Eve//stash"),
236					get_account_id_from_seed::<sr25519::Public>("Ferdie//stash"),245					get_account_id_from_seed::<sr25519::Public>("Ferdie//stash"),
237				],246				],
238				1000247				PARA_ID
239			)248			)
240		},249		},
241		// Bootnodes250		// Bootnodes
250		// Extensions259		// Extensions
251		Extensions {260		Extensions {
252			relay_chain: "rococo-dev".into(),261			relay_chain: "rococo-dev".into(),
253			para_id: 1000,262			para_id: PARA_ID,
254		},263		},
255	)264	)
256}265}
303					get_account_id_from_seed::<sr25519::Public>("Eve//stash"),312					get_account_id_from_seed::<sr25519::Public>("Eve//stash"),
304					get_account_id_from_seed::<sr25519::Public>("Ferdie//stash"),313					get_account_id_from_seed::<sr25519::Public>("Ferdie//stash"),
305				],314				],
306				1000315				PARA_ID
307			)316			)
308		},317		},
309		// Bootnodes318		// Bootnodes
318		// Extensions327		// Extensions
319		Extensions {328		Extensions {
320			relay_chain: "westend-local".into(),329			relay_chain: "westend-local".into(),
321			para_id: 1000,330			para_id: PARA_ID,
322		},331		},
323	)332	)
324}333}

168		QueryKind = ValueQuery,168		QueryKind = ValueQuery,
169	>;169	>;
170
171	/// Foreign collection flag
172	#[pallet::storage]
173	pub type ForeignCollection<T: Config> =
174		StorageMap<Hasher = Twox64Concat, Key = CollectionId, Value = bool, QueryKind = ValueQuery>;
170}175}
171176
172/// Wrapper around untyped collection handle, asserting inner collection is of fungible type.177/// Wrapper around untyped collection handle, asserting inner collection is of fungible type.
215		<PalletCommon<T>>::init_collection(owner, data, false)220		<PalletCommon<T>>::init_collection(owner, data, false)
216	}221	}
222
223	/// Initializes the collection with ForeignCollection flag. Returns [CollectionId] on success, [DispatchError] otherwise.
224	pub fn init_foreign_collection(
225		owner: T::CrossAccountId,
226		data: CreateCollectionData<T::AccountId>,
227	) -> Result<CollectionId, DispatchError> {
228		let id = <PalletCommon<T>>::init_collection(owner, data, false)?;
229		<ForeignCollection<T>>::insert(id, true);
230		Ok(id)
231	}
217232
218	/// Destroys a collection.233	/// Destroys a collection.
219	pub fn destroy_collection(234	pub fn destroy_collection(
230245
231		PalletCommon::destroy_collection(collection.0, sender)?;246		PalletCommon::destroy_collection(collection.0, sender)?;
232247
248		<ForeignCollection<T>>::remove(id);
233		<TotalSupply<T>>::remove(id);249		<TotalSupply<T>>::remove(id);
234		let _ = <Balance<T>>::clear_prefix((id,), u32::MAX, None);250		let _ = <Balance<T>>::clear_prefix((id,), u32::MAX, None);
235		let _ = <Allowance<T>>::clear_prefix((id,), u32::MAX, None);251		let _ = <Allowance<T>>::clear_prefix((id,), u32::MAX, None);
257			.checked_sub(amount)273			.checked_sub(amount)
258			.ok_or(<CommonError<T>>::TokenValueTooLow)?;274			.ok_or(<CommonError<T>>::TokenValueTooLow)?;
275
276		// Foreign collection check
277		ensure!(
278			!<ForeignCollection<T>>::get(collection.id),
279			<CommonError<T>>::NoPermission
280		);
259281
260		if collection.permissions.access() == AccessMode::AllowList {282		if collection.permissions.access() == AccessMode::AllowList {
261			collection.check_allowlist(owner)?;283			collection.check_allowlist(owner)?;
288		Ok(())310		Ok(())
289	}311	}
312
313	/// Burns the specified amount of the token.
314	pub fn burn_foreign(
315		collection: &FungibleHandle<T>,
316		owner: &T::CrossAccountId,
317		amount: u128,
318	) -> DispatchResult {
319		let total_supply = <TotalSupply<T>>::get(collection.id)
320			.checked_sub(amount)
321			.ok_or(<CommonError<T>>::TokenValueTooLow)?;
322
323		let balance = <Balance<T>>::get((collection.id, owner))
324			.checked_sub(amount)
325			.ok_or(<CommonError<T>>::TokenValueTooLow)?;
326		// =========
327
328		if balance == 0 {
329			<Balance<T>>::remove((collection.id, owner));
330			<PalletStructure<T>>::unnest_if_nested(owner, collection.id, TokenId::default());
331		} else {
332			<Balance<T>>::insert((collection.id, owner), balance);
333		}
334		<TotalSupply<T>>::insert(collection.id, total_supply);
335
336		<PalletEvm<T>>::deposit_log(
337			ERC20Events::Transfer {
338				from: *owner.as_eth(),
339				to: H160::default(),
340				value: amount.into(),
341			}
342			.to_log(collection_id_to_address(collection.id)),
343		);
344		<PalletCommon<T>>::deposit_event(CommonEvent::ItemDestroyed(
345			collection.id,
346			TokenId::default(),
347			owner.clone(),
348			amount,
349		));
350		Ok(())
351	}
290352
291	/// Transfers the specified amount of tokens. Will check that353	/// Transfers the specified amount of tokens. Will check that
292	/// the transfer is allowed for the token.354	/// the transfer is allowed for the token.
373		data: BTreeMap<T::CrossAccountId, u128>,435		data: BTreeMap<T::CrossAccountId, u128>,
374		nesting_budget: &dyn Budget,436		nesting_budget: &dyn Budget,
375	) -> DispatchResult {437	) -> DispatchResult {
438		// Foreign collection check
439		ensure!(
440			!<ForeignCollection<T>>::get(collection.id),
441			<CommonError<T>>::NoPermission
442		);
443
376		if !collection.is_owner_or_admin(sender) {444		if !collection.is_owner_or_admin(sender) {
377			ensure!(445			ensure!(
442		Ok(())510		Ok(())
443	}511	}
512
513	/// Minting tokens for multiple IDs.
514	/// See [`create_item_foreign`][`Pallet::create_item_foreign`] for more details.
515	pub fn create_multiple_items_foreign(
516		collection: &FungibleHandle<T>,
517		sender: &T::CrossAccountId,
518		data: BTreeMap<T::CrossAccountId, u128>,
519		nesting_budget: &dyn Budget,
520	) -> DispatchResult {
521		let total_supply = data
522			.iter()
523			.map(|(_, v)| *v)
524			.try_fold(<TotalSupply<T>>::get(collection.id), |acc, v| {
525				acc.checked_add(v)
526			})
527			.ok_or(ArithmeticError::Overflow)?;
528
529		let mut balances = data;
530		for (k, v) in balances.iter_mut() {
531			*v = <Balance<T>>::get((collection.id, &k))
532				.checked_add(*v)
533				.ok_or(ArithmeticError::Overflow)?;
534		}
535
536		for (to, _) in balances.iter() {
537			<PalletStructure<T>>::check_nesting(
538				sender.clone(),
539				to,
540				collection.id,
541				TokenId::default(),
542				nesting_budget,
543			)?;
544		}
545
546		// =========
547
548		<TotalSupply<T>>::insert(collection.id, total_supply);
549		for (user, amount) in balances {
550			<Balance<T>>::insert((collection.id, &user), amount);
551			<PalletStructure<T>>::nest_if_sent_to_token_unchecked(
552				&user,
553				collection.id,
554				TokenId::default(),
555			);
556			<PalletEvm<T>>::deposit_log(
557				ERC20Events::Transfer {
558					from: H160::default(),
559					to: *user.as_eth(),
560					value: amount.into(),
561				}
562				.to_log(collection_id_to_address(collection.id)),
563			);
564			<PalletCommon<T>>::deposit_event(CommonEvent::ItemCreated(
565				collection.id,
566				TokenId::default(),
567				user.clone(),
568				amount,
569			));
570		}
571
572		Ok(())
573	}
444574
445	fn set_allowance_unchecked(575	fn set_allowance_unchecked(
446		collection: &FungibleHandle<T>,576		collection: &FungibleHandle<T>,
615		)745		)
616	}746	}
747
748	///	Creates fungible token.
749	///
750	/// - `data`: Contains user who will become the owners of the tokens and amount
751	///   of tokens he will receive.
752	pub fn create_item_foreign(
753		collection: &FungibleHandle<T>,
754		sender: &T::CrossAccountId,
755		data: CreateItemData<T>,
756		nesting_budget: &dyn Budget,
757	) -> DispatchResult {
758		Self::create_multiple_items_foreign(
759			collection,
760			sender,
761			[(data.0, data.1)].into_iter().collect(),
762			nesting_budget,
763		)
764	}
617765
618	/// Returns 10 tokens owners in no particular order766	/// Returns 10 tokens owners in no particular order
619	///767	///

40#[cfg(feature = "scheduler")]40#[cfg(feature = "scheduler")]
41pub mod scheduler;41pub mod scheduler;
42
43#[cfg(feature = "foreign-assets")]
44pub mod foreign_asset;
4245
43parameter_types! {46parameter_types! {
44	pub TreasuryAccountId: AccountId = TreasuryModuleId::get().into_account_truncating();47	pub TreasuryAccountId: AccountId = TreasuryModuleId::get().into_account_truncating();

1616
17use frame_support::{17use frame_support::{
18	traits::{18	traits::{
19		tokens::currency::Currency as CurrencyT, OnUnbalanced as OnUnbalancedT, Get, Everything,19		Contains, tokens::currency::Currency as CurrencyT, OnUnbalanced as OnUnbalancedT, Get,
20		Everything, fungibles,
20	},21	},
21	weights::{Weight, WeightToFeePolynomial, WeightToFee},22	weights::{Weight, WeightToFeePolynomial, WeightToFee},
22	parameter_types, match_types,23	parameter_types, match_types,
34	Fungibility::Fungible as XcmFungible,35	Fungibility::Fungible as XcmFungible,
35	MultiAsset, Error as XcmError,36	MultiAsset, Error as XcmError,
36};37};
37use xcm_executor::traits::{MatchesFungible, WeightTrader};
38use xcm_builder::{38use xcm_builder::{
39	AccountId32Aliases, AllowTopLevelPaidExecutionFrom, CurrencyAdapter, EnsureXcmOrigin,39	AccountId32Aliases, AllowTopLevelPaidExecutionFrom, CurrencyAdapter, EnsureXcmOrigin,
40	FixedWeightBounds, LocationInverter, NativeAsset, ParentAsSuperuser, RelayChainAsNative,40	FixedWeightBounds, FungiblesAdapter, LocationInverter, NativeAsset, ParentAsSuperuser,
41	SiblingParachainAsNative, SiblingParachainConvertsVia, SignedAccountId32AsNative,41	RelayChainAsNative, SiblingParachainAsNative, SiblingParachainConvertsVia,
42	SignedToAccountId32, SovereignSignedViaLocation, TakeWeightCredit, ParentIsPreset,42	SignedAccountId32AsNative, SignedToAccountId32, SovereignSignedViaLocation, TakeWeightCredit,
43	ParentIsPreset, ConvertedConcreteAssetId,
43};44};
44use xcm_executor::{Config, XcmExecutor, Assets};45use xcm_executor::{Config, XcmExecutor, Assets};
46use xcm_executor::traits::{
47	Convert as ConvertXcm, JustTry, MatchesFungible, WeightTrader, FilterAssetLocation,
48};
49use pallet_foreing_assets::{
50	AssetIds, AssetIdMapping, XcmForeignAssetIdMapping, CurrencyId, NativeCurrency, FreeForAll,
51	TryAsForeing, ForeignAssetId,
52};
45use sp_std::marker::PhantomData;53use sp_std::{borrow::Borrow, marker::PhantomData, vec, vec::Vec};
46use crate::{54use crate::{
47	Runtime, Call, Event, Origin, Balances, ParachainInfo, ParachainSystem, PolkadotXcm, XcmpQueue,55	Runtime, Call, Event, Origin, Balances, ParachainInfo, ParachainSystem, PolkadotXcm, XcmpQueue,
56	xcm_config::Barrier,
48};57};
58#[cfg(feature = "foreign-assets")]
59use crate::ForeingAssets;
60
49use up_common::{61use up_common::{
50	types::{AccountId, Balance},62	types::{AccountId, Balance},
73pub struct OnlySelfCurrency;85pub struct OnlySelfCurrency;
74impl<B: TryFrom<u128>> MatchesFungible<B> for OnlySelfCurrency {86impl<B: TryFrom<u128>> MatchesFungible<B> for OnlySelfCurrency {
75	fn matches_fungible(a: &MultiAsset) -> Option<B> {87	fn matches_fungible(a: &MultiAsset) -> Option<B> {
88		let paraid = Parachain(ParachainInfo::parachain_id().into());
76		match (&a.id, &a.fun) {89		match (&a.id, &a.fun) {
90			(
91				Concrete(MultiLocation {
92					parents: 1,
93					interior: X1(loc),
94				}),
95				XcmFungible(ref amount),
96			) if paraid == *loc => CheckedConversion::checked_from(*amount),
77			(Concrete(_), XcmFungible(ref amount)) => CheckedConversion::checked_from(*amount),97			(
98				Concrete(MultiLocation {
99					parents: 0,
100					interior: Here,
101				}),
102				XcmFungible(ref amount),
103			) => CheckedConversion::checked_from(*amount),
78			_ => None,104			_ => None,
79		}105		}
145	};171	};
146}172}
147173
148pub type Barrier = (174/*
149	TakeWeightCredit,175pub type Barrier = (
150	AllowTopLevelPaidExecutionFrom<Everything>,176	TakeWeightCredit,
151	// ^^^ Parent & its unit plurality gets free execution177	AllowTopLevelPaidExecutionFrom<Everything>,
152);178	// ^^^ Parent & its unit plurality gets free execution
179);
180 */
153181
154pub struct UsingOnlySelfCurrencyComponents<182pub struct UsingOnlySelfCurrencyComponents<
155	WeightToFee: WeightToFeePolynomial<Balance = Currency::Balance>,183	WeightToFee: WeightToFeePolynomial<Balance = Currency::Balance>,
176	}204	}
177205
178	fn buy_weight(&mut self, weight: Weight, payment: Assets) -> Result<Assets, XcmError> {206	fn buy_weight(&mut self, weight: Weight, payment: Assets) -> Result<Assets, XcmError> {
179		let amount = WeightToFee::weight_to_fee(&weight);
180		let u128_amount: u128 = amount.try_into().map_err(|_| XcmError::Overflow)?;
181
182		// location to this parachain through relay chain
183		let option1: xcm::v1::AssetId = Concrete(MultiLocation {
184			parents: 1,
185			interior: X1(Parachain(ParachainInfo::parachain_id().into())),
186		});
187		// direct location
188		let option2: xcm::v1::AssetId = Concrete(MultiLocation {
189			parents: 0,
190			interior: Here,
191		});
192
193		let required = if payment.fungible.contains_key(&option1) {
194			(option1, u128_amount).into()
195		} else if payment.fungible.contains_key(&option2) {
196			(option2, u128_amount).into()
197		} else {
198			(Concrete(MultiLocation::default()), u128_amount).into()
199		};
200
201		let unused = payment
202			.checked_sub(required)
203			.map_err(|_| XcmError::TooExpensive)?;
204		self.0 = self.0.saturating_add(weight);
205		self.1 = self.1.saturating_add(amount);
206		Ok(unused)207		Ok(payment)
207	}208	}
208
209	fn refund_weight(&mut self, weight: Weight) -> Option<MultiAsset> {
210		let weight = weight.min(self.0);
211		let amount = WeightToFee::weight_to_fee(&weight);
212		self.0 -= weight;
213		self.1 = self.1.saturating_sub(amount);
214		let amount: u128 = amount.saturated_into();
215		if amount > 0 {
216			Some((AssetId::get(), amount).into())
217		} else {
218			None
219		}
220	}
221}209}
222impl<210impl<
223		WeightToFee: WeightToFeePolynomial<Balance = Currency::Balance>,211		WeightToFee: WeightToFeePolynomial<Balance = Currency::Balance>,
233	}221	}
234}222}
223
224parameter_types! {
225	pub CheckingAccount: AccountId = PolkadotXcm::check_account();
226}
227/// Allow checking in assets that have issuance > 0.
228#[cfg(feature = "foreign-assets")]
229pub struct NonZeroIssuance<AccountId, ForeingAssets>(PhantomData<(AccountId, ForeingAssets)>);
230
231#[cfg(feature = "foreign-assets")]
232impl<AccountId, ForeingAssets> Contains<<ForeingAssets as fungibles::Inspect<AccountId>>::AssetId>
233	for NonZeroIssuance<AccountId, ForeingAssets>
234where
235	ForeingAssets: fungibles::Inspect<AccountId>,
236{
237	fn contains(id: &<ForeingAssets as fungibles::Inspect<AccountId>>::AssetId) -> bool {
238		!ForeingAssets::total_issuance(*id).is_zero()
239	}
240}
241
242#[cfg(feature = "foreign-assets")]
243pub struct AsInnerId<AssetId, ConvertAssetId>(PhantomData<(AssetId, ConvertAssetId)>);
244#[cfg(feature = "foreign-assets")]
245impl<AssetId: Clone + PartialEq, ConvertAssetId: ConvertXcm<AssetId, AssetId>>
246	ConvertXcm<MultiLocation, AssetId> for AsInnerId<AssetId, ConvertAssetId>
247where
248	AssetId: Borrow<AssetId>,
249	AssetId: TryAsForeing<AssetId, ForeignAssetId>,
250	AssetIds: Borrow<AssetId>,
251{
252	fn convert_ref(id: impl Borrow<MultiLocation>) -> Result<AssetId, ()> {
253		let id = id.borrow();
254
255		log::trace!(
256			target: "xcm::AsInnerId::Convert",
257			"AsInnerId {:?}",
258			id
259		);
260
261		let parent = MultiLocation::parent();
262		let here = MultiLocation::here();
263		let self_location = MultiLocation::new(1, X1(Parachain(ParachainInfo::get().into())));
264
265		if *id == parent {
266			return ConvertAssetId::convert_ref(AssetIds::NativeAssetId(NativeCurrency::Parent));
267		}
268
269		if *id == here || *id == self_location {
270			return ConvertAssetId::convert_ref(AssetIds::NativeAssetId(NativeCurrency::Here));
271		}
272
273		match XcmForeignAssetIdMapping::<Runtime>::get_currency_id(id.clone()) {
274			Some(AssetIds::ForeignAssetId(foreign_asset_id)) => {
275				ConvertAssetId::convert_ref(AssetIds::ForeignAssetId(foreign_asset_id))
276			}
277			_ => ConvertAssetId::convert_ref(AssetIds::ForeignAssetId(0)),
278		}
279	}
280
281	fn reverse_ref(what: impl Borrow<AssetId>) -> Result<MultiLocation, ()> {
282		log::trace!(
283			target: "xcm::AsInnerId::Reverse",
284			"AsInnerId",
285		);
286
287		let asset_id = what.borrow();
288
289		let parent_id =
290			ConvertAssetId::convert_ref(AssetIds::NativeAssetId(NativeCurrency::Parent)).unwrap();
291		let here_id =
292			ConvertAssetId::convert_ref(AssetIds::NativeAssetId(NativeCurrency::Here)).unwrap();
293
294		if asset_id.clone() == parent_id {
295			return Ok(MultiLocation::parent());
296		}
297
298		if asset_id.clone() == here_id {
299			return Ok(MultiLocation::new(
300				1,
301				X1(Parachain(ParachainInfo::get().into())),
302			));
303		}
304
305		match <AssetId as TryAsForeing<AssetId, ForeignAssetId>>::try_as_foreing(asset_id.clone()) {
306			Some(fid) => match XcmForeignAssetIdMapping::<Runtime>::get_multi_location(fid) {
307				Some(location) => Ok(location),
308				None => Err(()),
309			},
310			None => Err(()),
311		}
312	}
313}
314
315/// Means for transacting assets besides the native currency on this chain.
316#[cfg(feature = "foreign-assets")]
317pub type FungiblesTransactor = FungiblesAdapter<
318	// Use this fungibles implementation:
319	ForeingAssets,
320	// Use this currency when it is a fungible asset matching the given location or name:
321	ConvertedConcreteAssetId<AssetIds, Balance, AsInnerId<AssetIds, JustTry>, JustTry>,
322	// Convert an XCM MultiLocation into a local account id:
323	LocationToAccountId,
324	// Our chain's account ID type (we can't get away without mentioning it explicitly):
325	AccountId,
326	// We only want to allow teleports of known assets. We use non-zero issuance as an indication
327	// that this asset is known.
328	NonZeroIssuance<AccountId, ForeingAssets>,
329	// The account to use for tracking teleports.
330	CheckingAccount,
331>;
332
333/// Means for transacting assets on this chain.
334#[cfg(feature = "foreign-assets")]
335pub type AssetTransactors = FungiblesTransactor;
336
337#[cfg(not(feature = "foreign-assets"))]
338pub type AssetTransactors = LocalAssetTransactor;
339
340#[cfg(feature = "foreign-assets")]
341pub struct AllAsset;
342#[cfg(feature = "foreign-assets")]
343impl FilterAssetLocation for AllAsset {
344	fn filter_asset_location(asset: &MultiAsset, origin: &MultiLocation) -> bool {
345		true
346	}
347}
348
349#[cfg(feature = "foreign-assets")]
350pub type IsReserve = AllAsset;
351#[cfg(not(feature = "foreign-assets"))]
352pub type IsReserve = NativeAsset;
353
354#[cfg(feature = "foreign-assets")]
355type Trader<T> = FreeForAll<
356	pallet_configuration::WeightToFee<T, Balance>,
357	RelayLocation,
358	AccountId,
359	Balances,
360	(),
361>;
362#[cfg(not(feature = "foreign-assets"))]
363type Trader<T> = UsingOnlySelfCurrencyComponents<
364	pallet_configuration::WeightToFee<T, Balance>,
365	RelayLocation,
366	AccountId,
367	Balances,
368	(),
369>;
235370
236pub struct XcmConfig<T>(PhantomData<T>);371pub struct XcmConfig<T>(PhantomData<T>);
237impl<T> Config for XcmConfig<T>372impl<T> Config for XcmConfig<T>
241	type Call = Call;376	type Call = Call;
242	type XcmSender = XcmRouter;377	type XcmSender = XcmRouter;
243	// How to withdraw and deposit an asset.378	// How to withdraw and deposit an asset.
244	type AssetTransactor = LocalAssetTransactor;379	type AssetTransactor = AssetTransactors;
245	type OriginConverter = XcmOriginToTransactDispatchOrigin;380	type OriginConverter = XcmOriginToTransactDispatchOrigin;
246	type IsReserve = NativeAsset;381	type IsReserve = IsReserve;
247	type IsTeleporter = (); // Teleportation is disabled382	type IsTeleporter = (); // Teleportation is disabled
248	type LocationInverter = LocationInverter<Ancestry>;383	type LocationInverter = LocationInverter<Ancestry>;
249	type Barrier = Barrier;384	type Barrier = Barrier;
250	type Weigher = FixedWeightBounds<UnitWeightCost, Call, MaxInstructions>;385	type Weigher = FixedWeightBounds<UnitWeightCost, Call, MaxInstructions>;
251	type Trader = UsingOnlySelfCurrencyComponents<386	type Trader = Trader<T>;
252		pallet_configuration::WeightToFee<T, Balance>,
253		RelayLocation,
254		AccountId,
255		Balances,
256		(),
257	>;
258	type ResponseHandler = (); // Don't handle responses for now.387	type ResponseHandler = (); // Don't handle responses for now.
259	type SubscriptionService = PolkadotXcm;388	type SubscriptionService = PolkadotXcm;