difftreelog
Merge pull request #1068 from UniqueNetwork/chore/migrate-foreign-asset-to-v4
in: master
migrate foreign asset to v4 + fix foreign flags
3 files changed
Cargo.lockdiffbeforeafterboth--- a/Cargo.lock
+++ b/Cargo.lock
@@ -7279,6 +7279,7 @@
name = "pallet-foreign-assets"
version = "0.1.0"
dependencies = [
+ "derivative",
"frame-benchmarking",
"frame-support",
"frame-system",
pallets/foreign-assets/Cargo.tomldiffbeforeafterboth--- a/pallets/foreign-assets/Cargo.toml
+++ b/pallets/foreign-assets/Cargo.toml
@@ -21,6 +21,7 @@
staging-xcm = { workspace = true }
staging-xcm-executor = { workspace = true }
up-data-structs = { workspace = true }
+derivative = { workspace = true }
[features]
default = ["std"]
pallets/foreign-assets/src/lib.rsdiffbeforeafterboth1// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.2// This file is part of Unique Network.34// Unique Network is free software: you can redistribute it and/or modify5// it under the terms of the GNU General Public License as published by6// the Free Software Foundation, either version 3 of the License, or7// (at your option) any later version.89// Unique Network is distributed in the hope that it will be useful,10// but WITHOUT ANY WARRANTY; without even the implied warranty of11// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the12// GNU General Public License for more details.1314// You should have received a copy of the GNU General Public License15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.1617//! # Foreign Assets18//!19//! ## Overview20//!21//! The Foreign Assets is a proxy that maps XCM operations to the Unique Network's pallets logic.2223#![cfg_attr(not(feature = "std"), no_std)]24#![allow(clippy::unused_unit)]2526use core::ops::Deref;2728use frame_support::{dispatch::DispatchResult, pallet_prelude::*, traits::EnsureOrigin, PalletId};29use frame_system::pallet_prelude::*;30use pallet_common::{31 dispatch::CollectionDispatch, erc::CrossAccountId, XcmExtensions, NATIVE_FUNGIBLE_COLLECTION_ID,32};33use sp_runtime::traits::AccountIdConversion;34use sp_std::{boxed::Box, vec, vec::Vec};35use staging_xcm::{v4::prelude::*, VersionedAssetId};36use staging_xcm_executor::{37 traits::{ConvertLocation, Error as XcmExecutorError, TransactAsset, WeightTrader},38 AssetsInHolding,39};40use up_data_structs::{41 budget::ZeroBudget, CollectionId, CollectionMode, CollectionName, CollectionTokenPrefix,42 CreateCollectionData, CreateFungibleData, CreateItemData, TokenId,43};4445pub mod weights;4647#[cfg(feature = "runtime-benchmarks")]48mod benchmarking;4950pub use module::*;51pub use weights::WeightInfo;5253#[frame_support::pallet]54pub mod module {55 use pallet_common::CollectionIssuer;56 use up_data_structs::CollectionDescription;5758 use super::*;5960 #[pallet::config]61 pub trait Config:62 frame_system::Config63 + pallet_common::Config64 + pallet_fungible::Config65 + pallet_balances::Config66 {67 /// The overarching event type.68 type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;6970 /// Origin for force registering of a foreign asset.71 type ForceRegisterOrigin: EnsureOrigin<Self::RuntimeOrigin>;7273 /// The ID of the foreign assets pallet.74 type PalletId: Get<PalletId>;7576 /// Self-location of this parachain.77 type SelfLocation: Get<Location>;7879 /// The converter from a Location to a CrossAccountId.80 type LocationToAccountId: ConvertLocation<Self::CrossAccountId>;8182 /// Weight information for the extrinsics in this module.83 type WeightInfo: WeightInfo;84 }8586 #[pallet::error]87 pub enum Error<T> {88 /// The foreign asset is already registered.89 ForeignAssetAlreadyRegistered,9091 /// The given asset ID could not be converted into the current XCM version.92 BadForeignAssetId,93 }9495 #[pallet::event]96 #[pallet::generate_deposit(fn deposit_event)]97 pub enum Event<T: Config> {98 /// The foreign asset registered.99 ForeignAssetRegistered {100 collection_id: CollectionId,101 asset_id: Box<VersionedAssetId>,102 },103 }104105 /// The corresponding collections of foreign assets.106 #[pallet::storage]107 #[pallet::getter(fn foreign_asset_to_collection)]108 pub type ForeignAssetToCollection<T: Config> =109 StorageMap<_, Twox64Concat, staging_xcm::v4::AssetId, CollectionId, OptionQuery>;110111 /// The corresponding foreign assets of collections.112 #[pallet::storage]113 #[pallet::getter(fn collection_to_foreign_asset)]114 pub type CollectionToForeignAsset<T: Config> =115 StorageMap<_, Twox64Concat, CollectionId, staging_xcm::v4::AssetId, OptionQuery>;116117 /// The correponding NFT token id of reserve NFTs118 #[pallet::storage]119 #[pallet::getter(fn foreign_reserve_asset_instance_to_token_id)]120 pub type ForeignReserveAssetInstanceToTokenId<T: Config> = StorageDoubleMap<121 Hasher1 = Twox64Concat,122 Key1 = CollectionId,123 Hasher2 = Blake2_128Concat,124 // Key2 = staging_xcm::v3::AssetInstance,125 Key2 = staging_xcm::v4::AssetInstance,126 Value = TokenId,127 QueryKind = OptionQuery,128 >;129130 /// The correponding reserve NFT of a token ID131 #[pallet::storage]132 #[pallet::getter(fn token_id_to_foreign_reserve_asset_instance)]133 pub type TokenIdToForeignReserveAssetInstance<T: Config> = StorageDoubleMap<134 Hasher1 = Twox64Concat,135 Key1 = CollectionId,136 Hasher2 = Blake2_128Concat,137 Key2 = TokenId,138 // Value = staging_xcm::v3::AssetInstance,139 Value = staging_xcm::v4::AssetInstance,140 QueryKind = OptionQuery,141 >;142143 #[pallet::pallet]144 pub struct Pallet<T>(_);145146 #[pallet::call]147 impl<T: Config> Pallet<T> {148 #[pallet::call_index(0)]149 #[pallet::weight(<T as Config>::WeightInfo::force_register_foreign_asset())]150 pub fn force_register_foreign_asset(151 origin: OriginFor<T>,152 versioned_asset_id: Box<VersionedAssetId>,153 name: CollectionName,154 token_prefix: CollectionTokenPrefix,155 mode: ForeignCollectionMode,156 ) -> DispatchResult {157 T::ForceRegisterOrigin::ensure_origin(origin.clone())?;158159 let asset_id: AssetId = versioned_asset_id160 .as_ref()161 .clone()162 .try_into()163 .map_err(|()| Error::<T>::BadForeignAssetId)?;164165 ensure!(166 !<ForeignAssetToCollection<T>>::contains_key(&asset_id),167 <Error<T>>::ForeignAssetAlreadyRegistered,168 );169170 let foreign_collection_owner = Self::pallet_account();171172 let description: CollectionDescription = "Foreign Assets Collection"173 .encode_utf16()174 .collect::<Vec<_>>()175 .try_into()176 .expect("description length < max description length; qed");177178 let collection_id = T::CollectionDispatch::create(179 foreign_collection_owner,180 CollectionIssuer::Internals,181 CreateCollectionData {182 name,183 token_prefix,184 description,185 mode: mode.into(),186 ..Default::default()187 },188 )?;189190 <ForeignAssetToCollection<T>>::insert(&asset_id, collection_id);191 <CollectionToForeignAsset<T>>::insert(collection_id, asset_id);192193 Self::deposit_event(Event::<T>::ForeignAssetRegistered {194 collection_id,195 asset_id: versioned_asset_id,196 });197198 Ok(())199 }200 }201}202203impl<T: Config> Pallet<T> {204 fn pallet_account() -> T::CrossAccountId {205 let owner: T::AccountId = T::PalletId::get().into_account_truncating();206 T::CrossAccountId::from_sub(owner)207 }208209 /// Converts a concrete asset ID (the asset multilocation) to a local collection on Unique Network.210 ///211 /// The multilocation corresponds to a local collection if:212 /// * It is `Here` location that corresponds to the native token of this parachain.213 /// * It is `../Parachain(<Unique Network Para ID>)` that also corresponds to the native token of this parachain.214 /// * It is `../Parachain(<Unique Network Para ID>)/GeneralIndex(<Collection ID>)` that corresponds215 /// to the collection with the ID equal to `<Collection ID>`. The `<Collection ID>` must be in the valid range,216 /// otherwise `None` is returned.217 /// * It is `GeneralIndex(<Collection ID>)`. Same as the last one above.218 ///219 /// If the multilocation doesn't match the patterns listed above,220 /// or the `<Collection ID>` points to a foreign collection,221 /// `None` is returned, identifying that the given multilocation doesn't correspond to a local collection.222 fn local_asset_id_to_collection(223 AssetId(asset_location): &AssetId,224 ) -> Option<CollectionLocality> {225 let self_location = T::SelfLocation::get();226227 if *asset_location == Here.into() || *asset_location == self_location {228 return Some(CollectionLocality::Local(NATIVE_FUNGIBLE_COLLECTION_ID));229 }230231 let prefix = if asset_location.parents == 0 {232 &Here233 } else if asset_location.parents == self_location.parents {234 &self_location.interior235 } else {236 return None;237 };238239 let GeneralIndex(collection_id) = asset_location.interior.match_and_split(prefix)? else {240 return None;241 };242243 let collection_id = CollectionId((*collection_id).try_into().ok()?);244245 Self::collection_to_foreign_asset(collection_id)246 .is_none()247 .then_some(CollectionLocality::Local(collection_id))248 }249250 /// Converts an asset ID to a Unique Network's collection locality (either foreign or a local one).251 ///252 /// The function will check if the asset's reserve location has the corresponding253 /// foreign collection on Unique Network,254 /// and will return the "foreign" locality containing the collection ID if found.255 ///256 /// If no corresponding foreign collection is found, the function will check257 /// if the asset's reserve location corresponds to a local collection.258 /// If the local collection is found, the "local" locality with the collection ID is returned.259 ///260 /// If all of the above have failed, the `AssetIdConversionFailed` error will be returned.261 fn asset_to_collection(asset_id: &AssetId) -> Result<CollectionLocality, XcmError> {262 Self::foreign_asset_to_collection(asset_id)263 .map(CollectionLocality::Foreign)264 .or_else(|| Self::local_asset_id_to_collection(asset_id))265 .ok_or_else(|| XcmExecutorError::AssetIdConversionFailed.into())266 }267268 /// Converts an XCM asset instance of local collection to the Unique Network's token ID.269 ///270 /// The asset instance corresponds to the Unique Network's token ID if it is in the following format:271 /// `AssetInstance::Index(<token ID>)`.272 ///273 /// If the asset instance is not in the valid format or the `<token ID>` can't fit into the valid token ID,274 /// `None` will be returned.275 ///276 /// Note: this function can return `Some` containing the token ID of a non-existing NFT.277 /// It returns `None` when it failed to convert the `asset_instance` to a local ID.278 fn local_asset_instance_to_token_id(asset_instance: &AssetInstance) -> Option<TokenId> {279 match asset_instance {280 AssetInstance::Index(token_id) => Some(TokenId((*token_id).try_into().ok()?)),281 _ => None,282 }283 }284285 /// Obtains the token ID of the `asset_instance` in the collection.286 ///287 /// Note: this function can return `Some` containing the token ID of a non-existing NFT.288 /// It returns `None` when it failed to convert the `asset_instance` to a local ID.289 fn asset_instance_to_token_id(290 collection_locality: CollectionLocality,291 asset_instance: &AssetInstance,292 ) -> Option<TokenId> {293 match collection_locality {294 CollectionLocality::Local(_) => Self::local_asset_instance_to_token_id(asset_instance),295 CollectionLocality::Foreign(collection_id) => {296 Self::foreign_reserve_asset_instance_to_token_id(collection_id, asset_instance)297 }298 }299 }300301 /// Creates a foreign item in the the collection.302 fn create_foreign_asset_instance(303 xcm_ext: &dyn XcmExtensions<T>,304 collection_id: CollectionId,305 asset_instance: &AssetInstance,306 to: T::CrossAccountId,307 ) -> DispatchResult {308 let derivative_token_id = xcm_ext.create_item(309 &Self::pallet_account(),310 to,311 CreateItemData::NFT(Default::default()),312 &ZeroBudget,313 )?;314315 <ForeignReserveAssetInstanceToTokenId<T>>::insert(316 collection_id,317 asset_instance,318 derivative_token_id,319 );320321 <TokenIdToForeignReserveAssetInstance<T>>::insert(322 collection_id,323 derivative_token_id,324 asset_instance,325 );326327 Ok(())328 }329330 /// Deposits an asset instance to the `to` account.331 ///332 /// Either transfers an existing item from the pallet's account333 /// or creates a foreign item.334 fn deposit_asset_instance(335 xcm_ext: &dyn XcmExtensions<T>,336 collection_locality: CollectionLocality,337 asset_instance: &AssetInstance,338 to: T::CrossAccountId,339 ) -> XcmResult {340 let token_id = Self::asset_instance_to_token_id(collection_locality, asset_instance);341342 let deposit_result = match (collection_locality, token_id) {343 (_, Some(token_id)) => {344 let depositor = &Self::pallet_account();345 let from = depositor;346 let amount = 1;347348 xcm_ext.transfer_item(depositor, from, &to, token_id, amount, &ZeroBudget)349 }350 (CollectionLocality::Foreign(collection_id), None) => {351 Self::create_foreign_asset_instance(xcm_ext, collection_id, asset_instance, to)352 }353 (CollectionLocality::Local(_), None) => {354 return Err(XcmExecutorError::InstanceConversionFailed.into());355 }356 };357358 deposit_result359 .map_err(|_| XcmError::FailedToTransactAsset("non-fungible item deposit failed"))360 }361362 /// Withdraws an asset instance from the `from` account.363 ///364 /// Transfers the asset instance to the pallet's account.365 fn withdraw_asset_instance(366 xcm_ext: &dyn XcmExtensions<T>,367 collection_locality: CollectionLocality,368 asset_instance: &AssetInstance,369 from: T::CrossAccountId,370 ) -> XcmResult {371 let token_id = Self::asset_instance_to_token_id(collection_locality, asset_instance)372 .ok_or(XcmExecutorError::InstanceConversionFailed)?;373374 let depositor = &from;375 let to = Self::pallet_account();376 let amount = 1;377 xcm_ext378 .transfer_item(depositor, &from, &to, token_id, amount, &ZeroBudget)379 .map_err(|_| XcmError::FailedToTransactAsset("non-fungible item withdraw failed"))?;380381 Ok(())382 }383}384385// #[derive()]386// pub enum Migration {387388// }389390impl<T: Config> TransactAsset for Pallet<T> {391 fn can_check_in(_origin: &Location, _what: &Asset, _context: &XcmContext) -> XcmResult {392 Err(XcmError::Unimplemented)393 }394395 fn check_in(_origin: &Location, _what: &Asset, _context: &XcmContext) {}396397 fn can_check_out(_dest: &Location, _what: &Asset, _context: &XcmContext) -> XcmResult {398 Err(XcmError::Unimplemented)399 }400401 fn check_out(_dest: &Location, _what: &Asset, _context: &XcmContext) {}402403 fn deposit_asset(what: &Asset, to: &Location, _context: Option<&XcmContext>) -> XcmResult {404 let to = T::LocationToAccountId::convert_location(to)405 .ok_or(XcmExecutorError::AccountIdConversionFailed)?;406407 let collection_locality = Self::asset_to_collection(&what.id)?;408 let dispatch = T::CollectionDispatch::dispatch(*collection_locality)409 .map_err(|_| XcmExecutorError::AssetIdConversionFailed)?;410411 let collection = dispatch.as_dyn();412 let xcm_ext = collection.xcm_extensions().ok_or(XcmError::Unimplemented)?;413414 match what.fun {415 Fungibility::Fungible(amount) => xcm_ext416 .create_item(417 &Self::pallet_account(),418 to,419 CreateItemData::Fungible(CreateFungibleData { value: amount }),420 &ZeroBudget,421 )422 .map(|_| ())423 .map_err(|_| XcmError::FailedToTransactAsset("fungible item deposit failed")),424425 Fungibility::NonFungible(asset_instance) => {426 Self::deposit_asset_instance(xcm_ext, collection_locality, &asset_instance, to)427 }428 }429 }430431 fn withdraw_asset(432 what: &Asset,433 from: &Location,434 _maybe_context: Option<&XcmContext>,435 ) -> Result<AssetsInHolding, XcmError> {436 let from = T::LocationToAccountId::convert_location(from)437 .ok_or(XcmExecutorError::AccountIdConversionFailed)?;438439 let collection_locality = Self::asset_to_collection(&what.id)?;440 let dispatch = T::CollectionDispatch::dispatch(*collection_locality)441 .map_err(|_| XcmExecutorError::AssetIdConversionFailed)?;442443 let collection = dispatch.as_dyn();444 let xcm_ext = collection.xcm_extensions().ok_or(XcmError::NoPermission)?;445446 match what.fun {447 Fungibility::Fungible(amount) => xcm_ext448 .burn_item(from, TokenId::default(), amount)449 .map_err(|_| XcmError::FailedToTransactAsset("fungible item withdraw failed"))?,450451 Fungibility::NonFungible(asset_instance) => {452 Self::withdraw_asset_instance(xcm_ext, collection_locality, &asset_instance, from)?;453 }454 }455456 Ok(what.clone().into())457 }458459 fn internal_transfer_asset(460 what: &Asset,461 from: &Location,462 to: &Location,463 _context: &XcmContext,464 ) -> Result<AssetsInHolding, XcmError> {465 let from = T::LocationToAccountId::convert_location(from)466 .ok_or(XcmExecutorError::AccountIdConversionFailed)?;467468 let to = T::LocationToAccountId::convert_location(to)469 .ok_or(XcmExecutorError::AccountIdConversionFailed)?;470471 let collection_locality = Self::asset_to_collection(&what.id)?;472473 let dispatch = T::CollectionDispatch::dispatch(*collection_locality)474 .map_err(|_| XcmExecutorError::AssetIdConversionFailed)?;475 let collection = dispatch.as_dyn();476 let xcm_ext = collection.xcm_extensions().ok_or(XcmError::NoPermission)?;477478 let depositor = &from;479480 let token_id;481 let amount;482 let map_error: fn(DispatchError) -> XcmError;483484 match what.fun {485 Fungibility::Fungible(fungible_amount) => {486 token_id = TokenId::default();487 amount = fungible_amount;488 map_error = |_| XcmError::FailedToTransactAsset("fungible item transfer failed");489 }490491 Fungibility::NonFungible(asset_instance) => {492 token_id = Self::asset_instance_to_token_id(collection_locality, &asset_instance)493 .ok_or(XcmExecutorError::InstanceConversionFailed)?;494495 amount = 1;496 map_error = |_| XcmError::FailedToTransactAsset("non-fungible item transfer failed")497 }498 }499500 xcm_ext501 .transfer_item(depositor, &from, &to, token_id, amount, &ZeroBudget)502 .map_err(map_error)?;503504 Ok(what.clone().into())505 }506}507508#[derive(Clone, Copy)]509pub enum CollectionLocality {510 Local(CollectionId),511 Foreign(CollectionId),512}513514impl Deref for CollectionLocality {515 type Target = CollectionId;516517 fn deref(&self) -> &Self::Target {518 match self {519 Self::Local(id) => id,520 Self::Foreign(id) => id,521 }522 }523}524525pub struct CurrencyIdConvert<T: Config>(PhantomData<T>);526impl<T: Config> sp_runtime::traits::Convert<CollectionId, Option<Location>>527 for CurrencyIdConvert<T>528{529 fn convert(collection_id: CollectionId) -> Option<Location> {530 if collection_id == NATIVE_FUNGIBLE_COLLECTION_ID {531 Some(T::SelfLocation::get())532 } else {533 <Pallet<T>>::collection_to_foreign_asset(collection_id)534 .map(|AssetId(location)| location)535 .or_else(|| {536 T::SelfLocation::get()537 .pushed_with_interior(GeneralIndex(collection_id.0.into()))538 .ok()539 })540 }541 }542}543544#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq, TypeInfo, MaxEncodedLen)]545pub enum ForeignCollectionMode {546 NFT,547 Fungible(u8),548}549550impl From<ForeignCollectionMode> for CollectionMode {551 fn from(value: ForeignCollectionMode) -> Self {552 match value {553 ForeignCollectionMode::NFT => Self::NFT,554 ForeignCollectionMode::Fungible(decimals) => Self::Fungible(decimals),555 }556 }557}558559pub struct FreeForAll;560561impl WeightTrader for FreeForAll {562 fn new() -> Self {563 Self564 }565566 fn buy_weight(567 &mut self,568 weight: Weight,569 payment: AssetsInHolding,570 _xcm: &XcmContext,571 ) -> Result<AssetsInHolding, XcmError> {572 log::trace!(target: "fassets::weight", "buy_weight weight: {:?}, payment: {:?}", weight, payment);573 Ok(payment)574 }575}1// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.2// This file is part of Unique Network.34// Unique Network is free software: you can redistribute it and/or modify5// it under the terms of the GNU General Public License as published by6// the Free Software Foundation, either version 3 of the License, or7// (at your option) any later version.89// Unique Network is distributed in the hope that it will be useful,10// but WITHOUT ANY WARRANTY; without even the implied warranty of11// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the12// GNU General Public License for more details.1314// You should have received a copy of the GNU General Public License15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.1617//! # Foreign Assets18//!19//! ## Overview20//!21//! The Foreign Assets is a proxy that maps XCM operations to the Unique Network's pallets logic.2223#![cfg_attr(not(feature = "std"), no_std)]24#![allow(clippy::unused_unit)]2526use core::ops::Deref;2728use derivative::Derivative;29use frame_support::{30 dispatch::DispatchResult, pallet_prelude::*, storage_alias, traits::EnsureOrigin, PalletId,31};32use frame_system::pallet_prelude::*;33use pallet_common::{34 dispatch::CollectionDispatch, erc::CrossAccountId, XcmExtensions, NATIVE_FUNGIBLE_COLLECTION_ID,35};36use sp_runtime::traits::AccountIdConversion;37use sp_std::{boxed::Box, vec, vec::Vec};38use staging_xcm::{v4::prelude::*, VersionedAssetId};39use staging_xcm_executor::{40 traits::{ConvertLocation, Error as XcmExecutorError, TransactAsset, WeightTrader},41 AssetsInHolding,42};43use up_data_structs::{44 budget::ZeroBudget, CollectionFlags, CollectionId, CollectionMode, CollectionName,45 CollectionTokenPrefix, CreateCollectionData, CreateFungibleData, CreateItemData, TokenId,46};4748pub mod weights;4950#[cfg(feature = "runtime-benchmarks")]51mod benchmarking;5253pub use module::*;54pub use weights::WeightInfo;5556/// Status of storage migration from an old XCM version to a new one.57#[derive(Clone, Copy, PartialEq, Eq, RuntimeDebug, Encode, Decode, TypeInfo, MaxEncodedLen)]58pub enum MigrationStatus {59 V3ToV4(MigrationStatusV3ToV4),60}6162/// Status of storage migration from XCMv3 to XCMv4.63#[derive(Clone, Copy, PartialEq, Eq, RuntimeDebug, Encode, Decode, TypeInfo, MaxEncodedLen)]64pub enum MigrationStatusV3ToV4 {65 /// The migration is completed.66 Done,6768 /// An asset is skipped during the migration69 /// due to its inconsistent state.70 SkippedInconsistentAssetData(staging_xcm::v3::AssetId),7172 /// An asset instance is skipped during the migration73 /// due to its inconsistent state.74 SkippedInconsistentAssetInstanceData {75 asset_id: staging_xcm::v3::AssetId,76 asset_instance: staging_xcm::v3::AssetInstance,77 },7879 /// An asset is skipped during the migration80 /// because it couldn't be converted to the new XCM version.81 SkippedNotConvertibleAssetId(staging_xcm::v3::AssetId),8283 /// An asset instance is skipped during the migration84 /// because it couldn't be converted to the new XCM version.85 SkippedNotConvertibleAssetInstance {86 asset_id: staging_xcm::v3::AssetId,87 asset_instance: staging_xcm::v3::AssetInstance,88 },89}9091#[frame_support::pallet]92pub mod module {93 use frame_support::traits::BuildGenesisConfig;94 use pallet_common::CollectionIssuer;95 use up_data_structs::CollectionDescription;9697 use super::*;9899 #[pallet::config]100 pub trait Config:101 frame_system::Config102 + pallet_common::Config103 + pallet_fungible::Config104 + pallet_balances::Config105 {106 /// The overarching event type.107 type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;108109 /// Origin for force registering of a foreign asset.110 type ForceRegisterOrigin: EnsureOrigin<Self::RuntimeOrigin>;111112 /// The ID of the foreign assets pallet.113 type PalletId: Get<PalletId>;114115 /// Self-location of this parachain.116 type SelfLocation: Get<Location>;117118 /// The converter from a Location to a CrossAccountId.119 type LocationToAccountId: ConvertLocation<Self::CrossAccountId>;120121 /// Weight information for the extrinsics in this module.122 type WeightInfo: WeightInfo;123 }124125 #[pallet::error]126 pub enum Error<T> {127 /// The foreign asset is already registered.128 ForeignAssetAlreadyRegistered,129130 /// The given asset ID could not be converted into the current XCM version.131 BadForeignAssetId,132 }133134 #[pallet::event]135 #[pallet::generate_deposit(pub(crate) fn deposit_event)]136 pub enum Event<T: Config> {137 /// The foreign asset registered.138 ForeignAssetRegistered {139 collection_id: CollectionId,140 asset_id: Box<VersionedAssetId>,141 },142143 /// The migration status.144 MigrationStatus(MigrationStatus),145 }146147 /// The corresponding collections of foreign assets.148 #[pallet::storage]149 #[pallet::getter(fn foreign_asset_to_collection)]150 pub type ForeignAssetToCollection<T: Config> =151 StorageMap<_, Blake2_128Concat, staging_xcm::v4::AssetId, CollectionId, OptionQuery>;152153 /// The corresponding foreign assets of collections.154 #[pallet::storage]155 #[pallet::getter(fn collection_to_foreign_asset)]156 pub type CollectionToForeignAsset<T: Config> =157 StorageMap<_, Blake2_128Concat, CollectionId, staging_xcm::v4::AssetId, OptionQuery>;158159 /// The correponding NFT token id of reserve NFTs160 #[pallet::storage]161 #[pallet::getter(fn foreign_reserve_asset_instance_to_token_id)]162 pub type ForeignReserveAssetInstanceToTokenId<T: Config> = StorageDoubleMap<163 Hasher1 = Blake2_128Concat,164 Key1 = CollectionId,165 Hasher2 = Blake2_128Concat,166 Key2 = staging_xcm::v4::AssetInstance,167 Value = TokenId,168 QueryKind = OptionQuery,169 >;170171 /// The correponding reserve NFT of a token ID172 #[pallet::storage]173 #[pallet::getter(fn token_id_to_foreign_reserve_asset_instance)]174 pub type TokenIdToForeignReserveAssetInstance<T: Config> = StorageDoubleMap<175 Hasher1 = Blake2_128Concat,176 Key1 = CollectionId,177 Hasher2 = Blake2_128Concat,178 Key2 = TokenId,179 Value = staging_xcm::v4::AssetInstance,180 QueryKind = OptionQuery,181 >;182183 const STORAGE_VERSION: StorageVersion = StorageVersion::new(staging_xcm::v4::VERSION as u16);184185 #[pallet::pallet]186 #[pallet::storage_version(STORAGE_VERSION)]187 pub struct Pallet<T>(_);188189 #[pallet::call]190 impl<T: Config> Pallet<T> {191 #[pallet::call_index(0)]192 #[pallet::weight(<T as Config>::WeightInfo::force_register_foreign_asset())]193 pub fn force_register_foreign_asset(194 origin: OriginFor<T>,195 versioned_asset_id: Box<VersionedAssetId>,196 name: CollectionName,197 token_prefix: CollectionTokenPrefix,198 mode: ForeignCollectionMode,199 ) -> DispatchResult {200 T::ForceRegisterOrigin::ensure_origin(origin.clone())?;201202 let asset_id: AssetId = versioned_asset_id203 .as_ref()204 .clone()205 .try_into()206 .map_err(|()| Error::<T>::BadForeignAssetId)?;207208 ensure!(209 !<ForeignAssetToCollection<T>>::contains_key(&asset_id),210 <Error<T>>::ForeignAssetAlreadyRegistered,211 );212213 let foreign_collection_owner = Self::pallet_account();214215 let description: CollectionDescription = "Foreign Assets Collection"216 .encode_utf16()217 .collect::<Vec<_>>()218 .try_into()219 .expect("description length < max description length; qed");220221 let collection_id = T::CollectionDispatch::create(222 foreign_collection_owner,223 CollectionIssuer::Internals,224 CreateCollectionData {225 name,226 token_prefix,227 description,228 mode: mode.into(),229 flags: CollectionFlags {230 foreign: true,231 ..Default::default()232 },233 ..Default::default()234 },235 )?;236237 <ForeignAssetToCollection<T>>::insert(&asset_id, collection_id);238 <CollectionToForeignAsset<T>>::insert(collection_id, asset_id);239240 Self::deposit_event(Event::<T>::ForeignAssetRegistered {241 collection_id,242 asset_id: versioned_asset_id,243 });244245 Ok(())246 }247 }248249 #[pallet::genesis_config]250 #[derive(Derivative)]251 #[derivative(Default(bound = ""))]252 pub struct GenesisConfig<T: Config>(PhantomData<T>);253254 #[pallet::genesis_build]255 impl<T: Config> BuildGenesisConfig for GenesisConfig<T> {256 fn build(&self) {257 <Pallet<T>>::in_code_storage_version().put::<Pallet<T>>();258 }259 }260261 #[pallet::hooks]262 impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {263 fn on_runtime_upgrade() -> Weight {264 if Self::on_chain_storage_version() < staging_xcm::v4::VERSION as u16 {265 let put_version_weight = T::DbWeight::get().writes(1);266 let fix_foreign_flag_weight = Self::fix_foreign_flag();267 let weight_v3_to_v4 = Self::migrate_v3_to_v4();268269 Self::in_code_storage_version().put::<Self>();270271 put_version_weight272 .saturating_add(fix_foreign_flag_weight)273 .saturating_add(weight_v3_to_v4)274 } else {275 Weight::zero()276 }277 }278 }279}280281mod v3_storage {282 use super::*;283284 #[storage_alias]285 pub type ForeignAssetToCollection<T: Config> =286 StorageMap<Pallet<T>, Twox64Concat, staging_xcm::v3::AssetId, CollectionId, OptionQuery>;287288 #[storage_alias]289 pub type CollectionToForeignAsset<T: Config> =290 StorageMap<Pallet<T>, Twox64Concat, CollectionId, staging_xcm::v3::AssetId, OptionQuery>;291292 #[storage_alias]293 pub type ForeignReserveAssetInstanceToTokenId<T: Config> = StorageDoubleMap<294 Pallet<T>,295 Twox64Concat,296 CollectionId,297 Blake2_128Concat,298 staging_xcm::v3::AssetInstance,299 TokenId,300 OptionQuery,301 >;302303 #[storage_alias]304 pub type TokenIdToForeignReserveAssetInstance<T: Config> = StorageDoubleMap<305 Pallet<T>,306 Twox64Concat,307 CollectionId,308 Blake2_128Concat,309 TokenId,310 staging_xcm::v3::AssetInstance,311 OptionQuery,312 >;313}314315impl<T: Config> Pallet<T> {316 fn fix_foreign_flag() -> Weight {317 let mut weight = Weight::zero();318319 for (_, collection_id) in v3_storage::ForeignAssetToCollection::<T>::iter() {320 pallet_common::CollectionById::<T>::mutate(collection_id, |collection| {321 if let Some(collection) = collection {322 collection.flags.foreign = true;323 }324 });325326 weight = weight.saturating_add(T::DbWeight::get().reads_writes(2, 1));327 }328329 weight330 }331332 fn migrate_v3_to_v4() -> Weight {333 let event_weight = T::DbWeight::get().writes(1);334 let collection_migration_weight = Self::migrate_collections();335336 Self::deposit_event(Event::<T>::MigrationStatus(MigrationStatus::V3ToV4(337 MigrationStatusV3ToV4::Done,338 )));339340 collection_migration_weight.saturating_add(event_weight)341 }342343 fn migrate_collections() -> Weight {344 use MigrationStatus::*;345 use MigrationStatusV3ToV4::*;346347 let mut weight = Weight::zero();348349 for (fwd_asset_id, collection_id) in v3_storage::ForeignAssetToCollection::<T>::drain() {350 let bwd_asset_id = v3_storage::CollectionToForeignAsset::<T>::take(collection_id);351 weight = weight.saturating_add(T::DbWeight::get().reads(2));352353 let Some(bwd_asset_id) = bwd_asset_id else {354 Self::deposit_event(Event::<T>::MigrationStatus(V3ToV4(355 SkippedInconsistentAssetData(fwd_asset_id),356 )));357358 weight = weight.saturating_add(T::DbWeight::get().writes(1));359 continue;360 };361362 if fwd_asset_id != bwd_asset_id {363 Self::deposit_event(Event::<T>::MigrationStatus(V3ToV4(364 SkippedInconsistentAssetData(fwd_asset_id),365 )));366367 weight = weight.saturating_add(T::DbWeight::get().writes(1));368 continue;369 }370371 let Ok(asset_id) = staging_xcm::v4::AssetId::try_from(fwd_asset_id) else {372 Self::deposit_event(Event::<T>::MigrationStatus(V3ToV4(373 SkippedNotConvertibleAssetId(fwd_asset_id),374 )));375376 weight = weight.saturating_add(T::DbWeight::get().writes(1));377 continue;378 };379380 <ForeignAssetToCollection<T>>::insert(&asset_id, collection_id);381 <CollectionToForeignAsset<T>>::insert(collection_id, asset_id);382 weight = weight.saturating_add(T::DbWeight::get().writes(2));383384 let migrate_tokens_weight = Self::migrate_tokens(&fwd_asset_id, collection_id);385 weight = weight.saturating_add(migrate_tokens_weight);386 }387388 weight389 }390391 fn migrate_tokens(asset_id: &staging_xcm::v3::AssetId, collection_id: CollectionId) -> Weight {392 use MigrationStatus::*;393 use MigrationStatusV3ToV4::*;394395 let mut weight = Weight::zero();396397 for (fwd_asset_instance, token_id) in398 v3_storage::ForeignReserveAssetInstanceToTokenId::<T>::drain_prefix(collection_id)399 {400 let bwd_asset_instance = v3_storage::TokenIdToForeignReserveAssetInstance::<T>::take(401 collection_id,402 token_id,403 );404 weight = weight.saturating_add(T::DbWeight::get().reads(2));405406 let Some(bwd_asset_instance) = bwd_asset_instance else {407 Self::deposit_event(Event::<T>::MigrationStatus(V3ToV4(408 SkippedInconsistentAssetInstanceData {409 asset_id: *asset_id,410 asset_instance: fwd_asset_instance,411 },412 )));413414 weight = weight.saturating_add(T::DbWeight::get().writes(1));415 continue;416 };417418 if fwd_asset_instance != bwd_asset_instance {419 Self::deposit_event(Event::<T>::MigrationStatus(V3ToV4(420 SkippedInconsistentAssetInstanceData {421 asset_id: *asset_id,422 asset_instance: fwd_asset_instance,423 },424 )));425426 weight = weight.saturating_add(T::DbWeight::get().writes(1));427 continue;428 }429430 let Ok(asset_instance) = staging_xcm::v4::AssetInstance::try_from(fwd_asset_instance)431 else {432 Self::deposit_event(Event::<T>::MigrationStatus(V3ToV4(433 SkippedNotConvertibleAssetInstance {434 asset_id: *asset_id,435 asset_instance: fwd_asset_instance,436 },437 )));438439 weight = weight.saturating_add(T::DbWeight::get().writes(1));440 continue;441 };442443 <ForeignReserveAssetInstanceToTokenId<T>>::insert(444 collection_id,445 &asset_instance,446 token_id,447 );448 <TokenIdToForeignReserveAssetInstance<T>>::insert(449 collection_id,450 token_id,451 asset_instance,452 );453 weight = weight.saturating_add(T::DbWeight::get().writes(2));454 }455456 weight457 }458459 fn pallet_account() -> T::CrossAccountId {460 let owner: T::AccountId = T::PalletId::get().into_account_truncating();461 T::CrossAccountId::from_sub(owner)462 }463464 /// Converts a concrete asset ID (the asset multilocation) to a local collection on Unique Network.465 ///466 /// The multilocation corresponds to a local collection if:467 /// * It is `Here` location that corresponds to the native token of this parachain.468 /// * It is `../Parachain(<Unique Network Para ID>)` that also corresponds to the native token of this parachain.469 /// * It is `../Parachain(<Unique Network Para ID>)/GeneralIndex(<Collection ID>)` that corresponds470 /// to the collection with the ID equal to `<Collection ID>`. The `<Collection ID>` must be in the valid range,471 /// otherwise `None` is returned.472 /// * It is `GeneralIndex(<Collection ID>)`. Same as the last one above.473 ///474 /// If the multilocation doesn't match the patterns listed above,475 /// or the `<Collection ID>` points to a foreign collection,476 /// `None` is returned, identifying that the given multilocation doesn't correspond to a local collection.477 fn local_asset_id_to_collection(478 AssetId(asset_location): &AssetId,479 ) -> Option<CollectionLocality> {480 let self_location = T::SelfLocation::get();481482 if *asset_location == Here.into() || *asset_location == self_location {483 return Some(CollectionLocality::Local(NATIVE_FUNGIBLE_COLLECTION_ID));484 }485486 let prefix = if asset_location.parents == 0 {487 &Here488 } else if asset_location.parents == self_location.parents {489 &self_location.interior490 } else {491 return None;492 };493494 let GeneralIndex(collection_id) = asset_location.interior.match_and_split(prefix)? else {495 return None;496 };497498 let collection_id = CollectionId((*collection_id).try_into().ok()?);499500 Self::collection_to_foreign_asset(collection_id)501 .is_none()502 .then_some(CollectionLocality::Local(collection_id))503 }504505 /// Converts an asset ID to a Unique Network's collection locality (either foreign or a local one).506 ///507 /// The function will check if the asset's reserve location has the corresponding508 /// foreign collection on Unique Network,509 /// and will return the "foreign" locality containing the collection ID if found.510 ///511 /// If no corresponding foreign collection is found, the function will check512 /// if the asset's reserve location corresponds to a local collection.513 /// If the local collection is found, the "local" locality with the collection ID is returned.514 ///515 /// If all of the above have failed, the `AssetIdConversionFailed` error will be returned.516 fn asset_to_collection(asset_id: &AssetId) -> Result<CollectionLocality, XcmError> {517 Self::foreign_asset_to_collection(asset_id)518 .map(CollectionLocality::Foreign)519 .or_else(|| Self::local_asset_id_to_collection(asset_id))520 .ok_or_else(|| XcmExecutorError::AssetIdConversionFailed.into())521 }522523 /// Converts an XCM asset instance of local collection to the Unique Network's token ID.524 ///525 /// The asset instance corresponds to the Unique Network's token ID if it is in the following format:526 /// `AssetInstance::Index(<token ID>)`.527 ///528 /// If the asset instance is not in the valid format or the `<token ID>` can't fit into the valid token ID,529 /// `None` will be returned.530 ///531 /// Note: this function can return `Some` containing the token ID of a non-existing NFT.532 /// It returns `None` when it failed to convert the `asset_instance` to a local ID.533 fn local_asset_instance_to_token_id(asset_instance: &AssetInstance) -> Option<TokenId> {534 match asset_instance {535 AssetInstance::Index(token_id) => Some(TokenId((*token_id).try_into().ok()?)),536 _ => None,537 }538 }539540 /// Obtains the token ID of the `asset_instance` in the collection.541 ///542 /// Note: this function can return `Some` containing the token ID of a non-existing NFT.543 /// It returns `None` when it failed to convert the `asset_instance` to a local ID.544 fn asset_instance_to_token_id(545 collection_locality: CollectionLocality,546 asset_instance: &AssetInstance,547 ) -> Option<TokenId> {548 match collection_locality {549 CollectionLocality::Local(_) => Self::local_asset_instance_to_token_id(asset_instance),550 CollectionLocality::Foreign(collection_id) => {551 Self::foreign_reserve_asset_instance_to_token_id(collection_id, asset_instance)552 }553 }554 }555556 /// Creates a foreign item in the the collection.557 fn create_foreign_asset_instance(558 xcm_ext: &dyn XcmExtensions<T>,559 collection_id: CollectionId,560 asset_instance: &AssetInstance,561 to: T::CrossAccountId,562 ) -> DispatchResult {563 let derivative_token_id = xcm_ext.create_item(564 &Self::pallet_account(),565 to,566 CreateItemData::NFT(Default::default()),567 &ZeroBudget,568 )?;569570 <ForeignReserveAssetInstanceToTokenId<T>>::insert(571 collection_id,572 asset_instance,573 derivative_token_id,574 );575576 <TokenIdToForeignReserveAssetInstance<T>>::insert(577 collection_id,578 derivative_token_id,579 asset_instance,580 );581582 Ok(())583 }584585 /// Deposits an asset instance to the `to` account.586 ///587 /// Either transfers an existing item from the pallet's account588 /// or creates a foreign item.589 fn deposit_asset_instance(590 xcm_ext: &dyn XcmExtensions<T>,591 collection_locality: CollectionLocality,592 asset_instance: &AssetInstance,593 to: T::CrossAccountId,594 ) -> XcmResult {595 let token_id = Self::asset_instance_to_token_id(collection_locality, asset_instance);596597 let deposit_result = match (collection_locality, token_id) {598 (_, Some(token_id)) => {599 let depositor = &Self::pallet_account();600 let from = depositor;601 let amount = 1;602603 xcm_ext.transfer_item(depositor, from, &to, token_id, amount, &ZeroBudget)604 }605 (CollectionLocality::Foreign(collection_id), None) => {606 Self::create_foreign_asset_instance(xcm_ext, collection_id, asset_instance, to)607 }608 (CollectionLocality::Local(_), None) => {609 return Err(XcmExecutorError::InstanceConversionFailed.into());610 }611 };612613 deposit_result614 .map_err(|_| XcmError::FailedToTransactAsset("non-fungible item deposit failed"))615 }616617 /// Withdraws an asset instance from the `from` account.618 ///619 /// Transfers the asset instance to the pallet's account.620 fn withdraw_asset_instance(621 xcm_ext: &dyn XcmExtensions<T>,622 collection_locality: CollectionLocality,623 asset_instance: &AssetInstance,624 from: T::CrossAccountId,625 ) -> XcmResult {626 let token_id = Self::asset_instance_to_token_id(collection_locality, asset_instance)627 .ok_or(XcmExecutorError::InstanceConversionFailed)?;628629 let depositor = &from;630 let to = Self::pallet_account();631 let amount = 1;632 xcm_ext633 .transfer_item(depositor, &from, &to, token_id, amount, &ZeroBudget)634 .map_err(|_| XcmError::FailedToTransactAsset("non-fungible item withdraw failed"))?;635636 Ok(())637 }638}639640// #[derive()]641// pub enum Migration {642643// }644645impl<T: Config> TransactAsset for Pallet<T> {646 fn can_check_in(_origin: &Location, _what: &Asset, _context: &XcmContext) -> XcmResult {647 Err(XcmError::Unimplemented)648 }649650 fn check_in(_origin: &Location, _what: &Asset, _context: &XcmContext) {}651652 fn can_check_out(_dest: &Location, _what: &Asset, _context: &XcmContext) -> XcmResult {653 Err(XcmError::Unimplemented)654 }655656 fn check_out(_dest: &Location, _what: &Asset, _context: &XcmContext) {}657658 fn deposit_asset(what: &Asset, to: &Location, _context: Option<&XcmContext>) -> XcmResult {659 let to = T::LocationToAccountId::convert_location(to)660 .ok_or(XcmExecutorError::AccountIdConversionFailed)?;661662 let collection_locality = Self::asset_to_collection(&what.id)?;663 let dispatch = T::CollectionDispatch::dispatch(*collection_locality)664 .map_err(|_| XcmExecutorError::AssetIdConversionFailed)?;665666 let collection = dispatch.as_dyn();667 let xcm_ext = collection.xcm_extensions().ok_or(XcmError::Unimplemented)?;668669 match what.fun {670 Fungibility::Fungible(amount) => xcm_ext671 .create_item(672 &Self::pallet_account(),673 to,674 CreateItemData::Fungible(CreateFungibleData { value: amount }),675 &ZeroBudget,676 )677 .map(|_| ())678 .map_err(|_| XcmError::FailedToTransactAsset("fungible item deposit failed")),679680 Fungibility::NonFungible(asset_instance) => {681 Self::deposit_asset_instance(xcm_ext, collection_locality, &asset_instance, to)682 }683 }684 }685686 fn withdraw_asset(687 what: &Asset,688 from: &Location,689 _maybe_context: Option<&XcmContext>,690 ) -> Result<AssetsInHolding, XcmError> {691 let from = T::LocationToAccountId::convert_location(from)692 .ok_or(XcmExecutorError::AccountIdConversionFailed)?;693694 let collection_locality = Self::asset_to_collection(&what.id)?;695 let dispatch = T::CollectionDispatch::dispatch(*collection_locality)696 .map_err(|_| XcmExecutorError::AssetIdConversionFailed)?;697698 let collection = dispatch.as_dyn();699 let xcm_ext = collection.xcm_extensions().ok_or(XcmError::NoPermission)?;700701 match what.fun {702 Fungibility::Fungible(amount) => xcm_ext703 .burn_item(from, TokenId::default(), amount)704 .map_err(|_| XcmError::FailedToTransactAsset("fungible item withdraw failed"))?,705706 Fungibility::NonFungible(asset_instance) => {707 Self::withdraw_asset_instance(xcm_ext, collection_locality, &asset_instance, from)?;708 }709 }710711 Ok(what.clone().into())712 }713714 fn internal_transfer_asset(715 what: &Asset,716 from: &Location,717 to: &Location,718 _context: &XcmContext,719 ) -> Result<AssetsInHolding, XcmError> {720 let from = T::LocationToAccountId::convert_location(from)721 .ok_or(XcmExecutorError::AccountIdConversionFailed)?;722723 let to = T::LocationToAccountId::convert_location(to)724 .ok_or(XcmExecutorError::AccountIdConversionFailed)?;725726 let collection_locality = Self::asset_to_collection(&what.id)?;727728 let dispatch = T::CollectionDispatch::dispatch(*collection_locality)729 .map_err(|_| XcmExecutorError::AssetIdConversionFailed)?;730 let collection = dispatch.as_dyn();731 let xcm_ext = collection.xcm_extensions().ok_or(XcmError::NoPermission)?;732733 let depositor = &from;734735 let token_id;736 let amount;737 let map_error: fn(DispatchError) -> XcmError;738739 match what.fun {740 Fungibility::Fungible(fungible_amount) => {741 token_id = TokenId::default();742 amount = fungible_amount;743 map_error = |_| XcmError::FailedToTransactAsset("fungible item transfer failed");744 }745746 Fungibility::NonFungible(asset_instance) => {747 token_id = Self::asset_instance_to_token_id(collection_locality, &asset_instance)748 .ok_or(XcmExecutorError::InstanceConversionFailed)?;749750 amount = 1;751 map_error = |_| XcmError::FailedToTransactAsset("non-fungible item transfer failed")752 }753 }754755 xcm_ext756 .transfer_item(depositor, &from, &to, token_id, amount, &ZeroBudget)757 .map_err(map_error)?;758759 Ok(what.clone().into())760 }761}762763#[derive(Clone, Copy)]764pub enum CollectionLocality {765 Local(CollectionId),766 Foreign(CollectionId),767}768769impl Deref for CollectionLocality {770 type Target = CollectionId;771772 fn deref(&self) -> &Self::Target {773 match self {774 Self::Local(id) => id,775 Self::Foreign(id) => id,776 }777 }778}779780pub struct CurrencyIdConvert<T: Config>(PhantomData<T>);781impl<T: Config> sp_runtime::traits::Convert<CollectionId, Option<Location>>782 for CurrencyIdConvert<T>783{784 fn convert(collection_id: CollectionId) -> Option<Location> {785 if collection_id == NATIVE_FUNGIBLE_COLLECTION_ID {786 Some(T::SelfLocation::get())787 } else {788 <Pallet<T>>::collection_to_foreign_asset(collection_id)789 .map(|AssetId(location)| location)790 .or_else(|| {791 T::SelfLocation::get()792 .pushed_with_interior(GeneralIndex(collection_id.0.into()))793 .ok()794 })795 }796 }797}798799#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq, TypeInfo, MaxEncodedLen)]800pub enum ForeignCollectionMode {801 NFT,802 Fungible(u8),803}804805impl From<ForeignCollectionMode> for CollectionMode {806 fn from(value: ForeignCollectionMode) -> Self {807 match value {808 ForeignCollectionMode::NFT => Self::NFT,809 ForeignCollectionMode::Fungible(decimals) => Self::Fungible(decimals),810 }811 }812}813814pub struct FreeForAll;815816impl WeightTrader for FreeForAll {817 fn new() -> Self {818 Self819 }820821 fn buy_weight(822 &mut self,823 weight: Weight,824 payment: AssetsInHolding,825 _xcm: &XcmContext,826 ) -> Result<AssetsInHolding, XcmError> {827 log::trace!(target: "fassets::weight", "buy_weight weight: {:?}, payment: {:?}", weight, payment);828 Ok(payment)829 }830}