difftreelog
fix(foreign-assets) put storage version in genesis config
in: master
1 file changed
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::{29 dispatch::DispatchResult, pallet_prelude::*, storage_alias, traits::EnsureOrigin, PalletId,30};31use frame_system::pallet_prelude::*;32use pallet_common::{33 dispatch::CollectionDispatch, erc::CrossAccountId, XcmExtensions, NATIVE_FUNGIBLE_COLLECTION_ID,34};35use sp_runtime::traits::AccountIdConversion;36use sp_std::{boxed::Box, vec, vec::Vec};37use staging_xcm::{v4::prelude::*, VersionedAssetId};38use staging_xcm_executor::{39 traits::{ConvertLocation, Error as XcmExecutorError, TransactAsset, WeightTrader},40 AssetsInHolding,41};42use up_data_structs::{43 budget::ZeroBudget, CollectionFlags, CollectionId, CollectionMode, CollectionName,44 CollectionTokenPrefix, CreateCollectionData, CreateFungibleData, CreateItemData, TokenId,45};4647pub mod weights;4849#[cfg(feature = "runtime-benchmarks")]50mod benchmarking;5152pub use module::*;53pub use weights::WeightInfo;5455/// Status of storage migration from an old XCM version to a new one.56#[derive(Clone, Copy, PartialEq, Eq, RuntimeDebug, Encode, Decode, TypeInfo, MaxEncodedLen)]57pub enum MigrationStatus {58 V3ToV4(MigrationStatusV3ToV4),59}6061/// Status of storage migration from XCMv3 to XCMv4.62#[derive(Clone, Copy, PartialEq, Eq, RuntimeDebug, Encode, Decode, TypeInfo, MaxEncodedLen)]63pub enum MigrationStatusV3ToV4 {64 /// The migration is completed.65 Done,6667 /// An asset is skipped during the migration68 /// due to its inconsistent state.69 SkippedInconsistentAssetData(staging_xcm::v3::AssetId),7071 /// An asset instance is skipped during the migration72 /// due to its inconsistent state.73 SkippedInconsistentAssetInstanceData {74 asset_id: staging_xcm::v3::AssetId,75 asset_instance: staging_xcm::v3::AssetInstance,76 },7778 /// An asset is skipped during the migration79 /// because it couldn't be converted to the new XCM version.80 SkippedNotConvertibleAssetId(staging_xcm::v3::AssetId),8182 /// An asset instance is skipped during the migration83 /// because it couldn't be converted to the new XCM version.84 SkippedNotConvertibleAssetInstance {85 asset_id: staging_xcm::v3::AssetId,86 asset_instance: staging_xcm::v3::AssetInstance,87 },88}8990#[frame_support::pallet]91pub mod module {92 use pallet_common::CollectionIssuer;93 use up_data_structs::CollectionDescription;9495 use super::*;9697 #[pallet::config]98 pub trait Config:99 frame_system::Config100 + pallet_common::Config101 + pallet_fungible::Config102 + pallet_balances::Config103 {104 /// The overarching event type.105 type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;106107 /// Origin for force registering of a foreign asset.108 type ForceRegisterOrigin: EnsureOrigin<Self::RuntimeOrigin>;109110 /// The ID of the foreign assets pallet.111 type PalletId: Get<PalletId>;112113 /// Self-location of this parachain.114 type SelfLocation: Get<Location>;115116 /// The converter from a Location to a CrossAccountId.117 type LocationToAccountId: ConvertLocation<Self::CrossAccountId>;118119 /// Weight information for the extrinsics in this module.120 type WeightInfo: WeightInfo;121 }122123 #[pallet::error]124 pub enum Error<T> {125 /// The foreign asset is already registered.126 ForeignAssetAlreadyRegistered,127128 /// The given asset ID could not be converted into the current XCM version.129 BadForeignAssetId,130 }131132 #[pallet::event]133 #[pallet::generate_deposit(pub(crate) fn deposit_event)]134 pub enum Event<T: Config> {135 /// The foreign asset registered.136 ForeignAssetRegistered {137 collection_id: CollectionId,138 asset_id: Box<VersionedAssetId>,139 },140141 /// The migration status.142 MigrationStatus(MigrationStatus),143 }144145 /// The corresponding collections of foreign assets.146 #[pallet::storage]147 #[pallet::getter(fn foreign_asset_to_collection)]148 pub type ForeignAssetToCollection<T: Config> =149 StorageMap<_, Blake2_128Concat, staging_xcm::v4::AssetId, CollectionId, OptionQuery>;150151 /// The corresponding foreign assets of collections.152 #[pallet::storage]153 #[pallet::getter(fn collection_to_foreign_asset)]154 pub type CollectionToForeignAsset<T: Config> =155 StorageMap<_, Blake2_128Concat, CollectionId, staging_xcm::v4::AssetId, OptionQuery>;156157 /// The correponding NFT token id of reserve NFTs158 #[pallet::storage]159 #[pallet::getter(fn foreign_reserve_asset_instance_to_token_id)]160 pub type ForeignReserveAssetInstanceToTokenId<T: Config> = StorageDoubleMap<161 Hasher1 = Blake2_128Concat,162 Key1 = CollectionId,163 Hasher2 = Blake2_128Concat,164 Key2 = staging_xcm::v4::AssetInstance,165 Value = TokenId,166 QueryKind = OptionQuery,167 >;168169 /// The correponding reserve NFT of a token ID170 #[pallet::storage]171 #[pallet::getter(fn token_id_to_foreign_reserve_asset_instance)]172 pub type TokenIdToForeignReserveAssetInstance<T: Config> = StorageDoubleMap<173 Hasher1 = Blake2_128Concat,174 Key1 = CollectionId,175 Hasher2 = Blake2_128Concat,176 Key2 = TokenId,177 Value = staging_xcm::v4::AssetInstance,178 QueryKind = OptionQuery,179 >;180181 const STORAGE_VERSION: StorageVersion = StorageVersion::new(staging_xcm::v4::VERSION as u16);182183 #[pallet::pallet]184 #[pallet::storage_version(STORAGE_VERSION)]185 pub struct Pallet<T>(_);186187 #[pallet::call]188 impl<T: Config> Pallet<T> {189 #[pallet::call_index(0)]190 #[pallet::weight(<T as Config>::WeightInfo::force_register_foreign_asset())]191 pub fn force_register_foreign_asset(192 origin: OriginFor<T>,193 versioned_asset_id: Box<VersionedAssetId>,194 name: CollectionName,195 token_prefix: CollectionTokenPrefix,196 mode: ForeignCollectionMode,197 ) -> DispatchResult {198 T::ForceRegisterOrigin::ensure_origin(origin.clone())?;199200 let asset_id: AssetId = versioned_asset_id201 .as_ref()202 .clone()203 .try_into()204 .map_err(|()| Error::<T>::BadForeignAssetId)?;205206 ensure!(207 !<ForeignAssetToCollection<T>>::contains_key(&asset_id),208 <Error<T>>::ForeignAssetAlreadyRegistered,209 );210211 let foreign_collection_owner = Self::pallet_account();212213 let description: CollectionDescription = "Foreign Assets Collection"214 .encode_utf16()215 .collect::<Vec<_>>()216 .try_into()217 .expect("description length < max description length; qed");218219 let collection_id = T::CollectionDispatch::create(220 foreign_collection_owner,221 CollectionIssuer::Internals,222 CreateCollectionData {223 name,224 token_prefix,225 description,226 mode: mode.into(),227 flags: CollectionFlags {228 foreign: true,229 ..Default::default()230 },231 ..Default::default()232 },233 )?;234235 <ForeignAssetToCollection<T>>::insert(&asset_id, collection_id);236 <CollectionToForeignAsset<T>>::insert(collection_id, asset_id);237238 Self::deposit_event(Event::<T>::ForeignAssetRegistered {239 collection_id,240 asset_id: versioned_asset_id,241 });242243 Ok(())244 }245 }246247 #[pallet::hooks]248 impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {249 fn on_runtime_upgrade() -> Weight {250 if Self::on_chain_storage_version() < staging_xcm::v4::VERSION as u16 {251 let put_version_weight = T::DbWeight::get().writes(1);252 let fix_foreign_flag_weight = Self::fix_foreign_flag();253 let weight_v3_to_v4 = Self::migrate_v3_to_v4();254255 StorageVersion::new(staging_xcm::v4::VERSION as u16).put::<Self>();256257 put_version_weight258 .saturating_add(fix_foreign_flag_weight)259 .saturating_add(weight_v3_to_v4)260 } else {261 Weight::zero()262 }263 }264 }265}266267mod v3_storage {268 use super::*;269270 #[storage_alias]271 pub type ForeignAssetToCollection<T: Config> =272 StorageMap<Pallet<T>, Twox64Concat, staging_xcm::v3::AssetId, CollectionId, OptionQuery>;273274 #[storage_alias]275 pub type CollectionToForeignAsset<T: Config> =276 StorageMap<Pallet<T>, Twox64Concat, CollectionId, staging_xcm::v3::AssetId, OptionQuery>;277278 #[storage_alias]279 pub type ForeignReserveAssetInstanceToTokenId<T: Config> = StorageDoubleMap<280 Pallet<T>,281 Twox64Concat,282 CollectionId,283 Blake2_128Concat,284 staging_xcm::v3::AssetInstance,285 TokenId,286 OptionQuery,287 >;288289 #[storage_alias]290 pub type TokenIdToForeignReserveAssetInstance<T: Config> = StorageDoubleMap<291 Pallet<T>,292 Twox64Concat,293 CollectionId,294 Blake2_128Concat,295 TokenId,296 staging_xcm::v3::AssetInstance,297 OptionQuery,298 >;299}300301impl<T: Config> Pallet<T> {302 fn fix_foreign_flag() -> Weight {303 let mut weight = Weight::zero();304305 for (_, collection_id) in v3_storage::ForeignAssetToCollection::<T>::iter() {306 pallet_common::CollectionById::<T>::mutate(collection_id, |collection| {307 if let Some(collection) = collection {308 collection.flags.foreign = true;309 }310 });311312 weight = weight.saturating_add(T::DbWeight::get().reads_writes(2, 1));313 }314315 weight316 }317318 fn migrate_v3_to_v4() -> Weight {319 let event_weight = T::DbWeight::get().writes(1);320 let collection_migration_weight = Self::migrate_collections();321322 Self::deposit_event(Event::<T>::MigrationStatus(MigrationStatus::V3ToV4(323 MigrationStatusV3ToV4::Done,324 )));325326 collection_migration_weight.saturating_add(event_weight)327 }328329 fn migrate_collections() -> Weight {330 use MigrationStatus::*;331 use MigrationStatusV3ToV4::*;332333 let mut weight = Weight::zero();334335 for (fwd_asset_id, collection_id) in v3_storage::ForeignAssetToCollection::<T>::drain() {336 let bwd_asset_id = v3_storage::CollectionToForeignAsset::<T>::take(collection_id);337 weight = weight.saturating_add(T::DbWeight::get().reads(2));338339 let Some(bwd_asset_id) = bwd_asset_id else {340 Self::deposit_event(Event::<T>::MigrationStatus(V3ToV4(341 SkippedInconsistentAssetData(fwd_asset_id),342 )));343344 weight = weight.saturating_add(T::DbWeight::get().writes(1));345 continue;346 };347348 if fwd_asset_id != bwd_asset_id {349 Self::deposit_event(Event::<T>::MigrationStatus(V3ToV4(350 SkippedInconsistentAssetData(fwd_asset_id),351 )));352353 weight = weight.saturating_add(T::DbWeight::get().writes(1));354 continue;355 }356357 let Ok(asset_id) = staging_xcm::v4::AssetId::try_from(fwd_asset_id) else {358 Self::deposit_event(Event::<T>::MigrationStatus(V3ToV4(359 SkippedNotConvertibleAssetId(fwd_asset_id),360 )));361362 weight = weight.saturating_add(T::DbWeight::get().writes(1));363 continue;364 };365366 <ForeignAssetToCollection<T>>::insert(&asset_id, collection_id);367 <CollectionToForeignAsset<T>>::insert(collection_id, asset_id);368 weight = weight.saturating_add(T::DbWeight::get().writes(2));369370 let migrate_tokens_weight = Self::migrate_tokens(&fwd_asset_id, collection_id);371 weight = weight.saturating_add(migrate_tokens_weight);372 }373374 weight375 }376377 fn migrate_tokens(asset_id: &staging_xcm::v3::AssetId, collection_id: CollectionId) -> Weight {378 use MigrationStatus::*;379 use MigrationStatusV3ToV4::*;380381 let mut weight = Weight::zero();382383 for (fwd_asset_instance, token_id) in384 v3_storage::ForeignReserveAssetInstanceToTokenId::<T>::drain_prefix(collection_id)385 {386 let bwd_asset_instance = v3_storage::TokenIdToForeignReserveAssetInstance::<T>::take(387 collection_id,388 token_id,389 );390 weight = weight.saturating_add(T::DbWeight::get().reads(2));391392 let Some(bwd_asset_instance) = bwd_asset_instance else {393 Self::deposit_event(Event::<T>::MigrationStatus(V3ToV4(394 SkippedInconsistentAssetInstanceData {395 asset_id: *asset_id,396 asset_instance: fwd_asset_instance,397 },398 )));399400 weight = weight.saturating_add(T::DbWeight::get().writes(1));401 continue;402 };403404 if fwd_asset_instance != bwd_asset_instance {405 Self::deposit_event(Event::<T>::MigrationStatus(V3ToV4(406 SkippedInconsistentAssetInstanceData {407 asset_id: *asset_id,408 asset_instance: fwd_asset_instance,409 },410 )));411412 weight = weight.saturating_add(T::DbWeight::get().writes(1));413 continue;414 }415416 let Ok(asset_instance) = staging_xcm::v4::AssetInstance::try_from(fwd_asset_instance)417 else {418 Self::deposit_event(Event::<T>::MigrationStatus(V3ToV4(419 SkippedNotConvertibleAssetInstance {420 asset_id: *asset_id,421 asset_instance: fwd_asset_instance,422 },423 )));424425 weight = weight.saturating_add(T::DbWeight::get().writes(1));426 continue;427 };428429 <ForeignReserveAssetInstanceToTokenId<T>>::insert(430 collection_id,431 &asset_instance,432 token_id,433 );434 <TokenIdToForeignReserveAssetInstance<T>>::insert(435 collection_id,436 token_id,437 asset_instance,438 );439 weight = weight.saturating_add(T::DbWeight::get().writes(2));440 }441442 weight443 }444445 fn pallet_account() -> T::CrossAccountId {446 let owner: T::AccountId = T::PalletId::get().into_account_truncating();447 T::CrossAccountId::from_sub(owner)448 }449450 /// Converts a concrete asset ID (the asset multilocation) to a local collection on Unique Network.451 ///452 /// The multilocation corresponds to a local collection if:453 /// * It is `Here` location that corresponds to the native token of this parachain.454 /// * It is `../Parachain(<Unique Network Para ID>)` that also corresponds to the native token of this parachain.455 /// * It is `../Parachain(<Unique Network Para ID>)/GeneralIndex(<Collection ID>)` that corresponds456 /// to the collection with the ID equal to `<Collection ID>`. The `<Collection ID>` must be in the valid range,457 /// otherwise `None` is returned.458 /// * It is `GeneralIndex(<Collection ID>)`. Same as the last one above.459 ///460 /// If the multilocation doesn't match the patterns listed above,461 /// or the `<Collection ID>` points to a foreign collection,462 /// `None` is returned, identifying that the given multilocation doesn't correspond to a local collection.463 fn local_asset_id_to_collection(464 AssetId(asset_location): &AssetId,465 ) -> Option<CollectionLocality> {466 let self_location = T::SelfLocation::get();467468 if *asset_location == Here.into() || *asset_location == self_location {469 return Some(CollectionLocality::Local(NATIVE_FUNGIBLE_COLLECTION_ID));470 }471472 let prefix = if asset_location.parents == 0 {473 &Here474 } else if asset_location.parents == self_location.parents {475 &self_location.interior476 } else {477 return None;478 };479480 let GeneralIndex(collection_id) = asset_location.interior.match_and_split(prefix)? else {481 return None;482 };483484 let collection_id = CollectionId((*collection_id).try_into().ok()?);485486 Self::collection_to_foreign_asset(collection_id)487 .is_none()488 .then_some(CollectionLocality::Local(collection_id))489 }490491 /// Converts an asset ID to a Unique Network's collection locality (either foreign or a local one).492 ///493 /// The function will check if the asset's reserve location has the corresponding494 /// foreign collection on Unique Network,495 /// and will return the "foreign" locality containing the collection ID if found.496 ///497 /// If no corresponding foreign collection is found, the function will check498 /// if the asset's reserve location corresponds to a local collection.499 /// If the local collection is found, the "local" locality with the collection ID is returned.500 ///501 /// If all of the above have failed, the `AssetIdConversionFailed` error will be returned.502 fn asset_to_collection(asset_id: &AssetId) -> Result<CollectionLocality, XcmError> {503 Self::foreign_asset_to_collection(asset_id)504 .map(CollectionLocality::Foreign)505 .or_else(|| Self::local_asset_id_to_collection(asset_id))506 .ok_or_else(|| XcmExecutorError::AssetIdConversionFailed.into())507 }508509 /// Converts an XCM asset instance of local collection to the Unique Network's token ID.510 ///511 /// The asset instance corresponds to the Unique Network's token ID if it is in the following format:512 /// `AssetInstance::Index(<token ID>)`.513 ///514 /// If the asset instance is not in the valid format or the `<token ID>` can't fit into the valid token ID,515 /// `None` will be returned.516 ///517 /// Note: this function can return `Some` containing the token ID of a non-existing NFT.518 /// It returns `None` when it failed to convert the `asset_instance` to a local ID.519 fn local_asset_instance_to_token_id(asset_instance: &AssetInstance) -> Option<TokenId> {520 match asset_instance {521 AssetInstance::Index(token_id) => Some(TokenId((*token_id).try_into().ok()?)),522 _ => None,523 }524 }525526 /// Obtains the token ID of the `asset_instance` in the collection.527 ///528 /// Note: this function can return `Some` containing the token ID of a non-existing NFT.529 /// It returns `None` when it failed to convert the `asset_instance` to a local ID.530 fn asset_instance_to_token_id(531 collection_locality: CollectionLocality,532 asset_instance: &AssetInstance,533 ) -> Option<TokenId> {534 match collection_locality {535 CollectionLocality::Local(_) => Self::local_asset_instance_to_token_id(asset_instance),536 CollectionLocality::Foreign(collection_id) => {537 Self::foreign_reserve_asset_instance_to_token_id(collection_id, asset_instance)538 }539 }540 }541542 /// Creates a foreign item in the the collection.543 fn create_foreign_asset_instance(544 xcm_ext: &dyn XcmExtensions<T>,545 collection_id: CollectionId,546 asset_instance: &AssetInstance,547 to: T::CrossAccountId,548 ) -> DispatchResult {549 let derivative_token_id = xcm_ext.create_item(550 &Self::pallet_account(),551 to,552 CreateItemData::NFT(Default::default()),553 &ZeroBudget,554 )?;555556 <ForeignReserveAssetInstanceToTokenId<T>>::insert(557 collection_id,558 asset_instance,559 derivative_token_id,560 );561562 <TokenIdToForeignReserveAssetInstance<T>>::insert(563 collection_id,564 derivative_token_id,565 asset_instance,566 );567568 Ok(())569 }570571 /// Deposits an asset instance to the `to` account.572 ///573 /// Either transfers an existing item from the pallet's account574 /// or creates a foreign item.575 fn deposit_asset_instance(576 xcm_ext: &dyn XcmExtensions<T>,577 collection_locality: CollectionLocality,578 asset_instance: &AssetInstance,579 to: T::CrossAccountId,580 ) -> XcmResult {581 let token_id = Self::asset_instance_to_token_id(collection_locality, asset_instance);582583 let deposit_result = match (collection_locality, token_id) {584 (_, Some(token_id)) => {585 let depositor = &Self::pallet_account();586 let from = depositor;587 let amount = 1;588589 xcm_ext.transfer_item(depositor, from, &to, token_id, amount, &ZeroBudget)590 }591 (CollectionLocality::Foreign(collection_id), None) => {592 Self::create_foreign_asset_instance(xcm_ext, collection_id, asset_instance, to)593 }594 (CollectionLocality::Local(_), None) => {595 return Err(XcmExecutorError::InstanceConversionFailed.into());596 }597 };598599 deposit_result600 .map_err(|_| XcmError::FailedToTransactAsset("non-fungible item deposit failed"))601 }602603 /// Withdraws an asset instance from the `from` account.604 ///605 /// Transfers the asset instance to the pallet's account.606 fn withdraw_asset_instance(607 xcm_ext: &dyn XcmExtensions<T>,608 collection_locality: CollectionLocality,609 asset_instance: &AssetInstance,610 from: T::CrossAccountId,611 ) -> XcmResult {612 let token_id = Self::asset_instance_to_token_id(collection_locality, asset_instance)613 .ok_or(XcmExecutorError::InstanceConversionFailed)?;614615 let depositor = &from;616 let to = Self::pallet_account();617 let amount = 1;618 xcm_ext619 .transfer_item(depositor, &from, &to, token_id, amount, &ZeroBudget)620 .map_err(|_| XcmError::FailedToTransactAsset("non-fungible item withdraw failed"))?;621622 Ok(())623 }624}625626// #[derive()]627// pub enum Migration {628629// }630631impl<T: Config> TransactAsset for Pallet<T> {632 fn can_check_in(_origin: &Location, _what: &Asset, _context: &XcmContext) -> XcmResult {633 Err(XcmError::Unimplemented)634 }635636 fn check_in(_origin: &Location, _what: &Asset, _context: &XcmContext) {}637638 fn can_check_out(_dest: &Location, _what: &Asset, _context: &XcmContext) -> XcmResult {639 Err(XcmError::Unimplemented)640 }641642 fn check_out(_dest: &Location, _what: &Asset, _context: &XcmContext) {}643644 fn deposit_asset(what: &Asset, to: &Location, _context: Option<&XcmContext>) -> XcmResult {645 let to = T::LocationToAccountId::convert_location(to)646 .ok_or(XcmExecutorError::AccountIdConversionFailed)?;647648 let collection_locality = Self::asset_to_collection(&what.id)?;649 let dispatch = T::CollectionDispatch::dispatch(*collection_locality)650 .map_err(|_| XcmExecutorError::AssetIdConversionFailed)?;651652 let collection = dispatch.as_dyn();653 let xcm_ext = collection.xcm_extensions().ok_or(XcmError::Unimplemented)?;654655 match what.fun {656 Fungibility::Fungible(amount) => xcm_ext657 .create_item(658 &Self::pallet_account(),659 to,660 CreateItemData::Fungible(CreateFungibleData { value: amount }),661 &ZeroBudget,662 )663 .map(|_| ())664 .map_err(|_| XcmError::FailedToTransactAsset("fungible item deposit failed")),665666 Fungibility::NonFungible(asset_instance) => {667 Self::deposit_asset_instance(xcm_ext, collection_locality, &asset_instance, to)668 }669 }670 }671672 fn withdraw_asset(673 what: &Asset,674 from: &Location,675 _maybe_context: Option<&XcmContext>,676 ) -> Result<AssetsInHolding, XcmError> {677 let from = T::LocationToAccountId::convert_location(from)678 .ok_or(XcmExecutorError::AccountIdConversionFailed)?;679680 let collection_locality = Self::asset_to_collection(&what.id)?;681 let dispatch = T::CollectionDispatch::dispatch(*collection_locality)682 .map_err(|_| XcmExecutorError::AssetIdConversionFailed)?;683684 let collection = dispatch.as_dyn();685 let xcm_ext = collection.xcm_extensions().ok_or(XcmError::NoPermission)?;686687 match what.fun {688 Fungibility::Fungible(amount) => xcm_ext689 .burn_item(from, TokenId::default(), amount)690 .map_err(|_| XcmError::FailedToTransactAsset("fungible item withdraw failed"))?,691692 Fungibility::NonFungible(asset_instance) => {693 Self::withdraw_asset_instance(xcm_ext, collection_locality, &asset_instance, from)?;694 }695 }696697 Ok(what.clone().into())698 }699700 fn internal_transfer_asset(701 what: &Asset,702 from: &Location,703 to: &Location,704 _context: &XcmContext,705 ) -> Result<AssetsInHolding, XcmError> {706 let from = T::LocationToAccountId::convert_location(from)707 .ok_or(XcmExecutorError::AccountIdConversionFailed)?;708709 let to = T::LocationToAccountId::convert_location(to)710 .ok_or(XcmExecutorError::AccountIdConversionFailed)?;711712 let collection_locality = Self::asset_to_collection(&what.id)?;713714 let dispatch = T::CollectionDispatch::dispatch(*collection_locality)715 .map_err(|_| XcmExecutorError::AssetIdConversionFailed)?;716 let collection = dispatch.as_dyn();717 let xcm_ext = collection.xcm_extensions().ok_or(XcmError::NoPermission)?;718719 let depositor = &from;720721 let token_id;722 let amount;723 let map_error: fn(DispatchError) -> XcmError;724725 match what.fun {726 Fungibility::Fungible(fungible_amount) => {727 token_id = TokenId::default();728 amount = fungible_amount;729 map_error = |_| XcmError::FailedToTransactAsset("fungible item transfer failed");730 }731732 Fungibility::NonFungible(asset_instance) => {733 token_id = Self::asset_instance_to_token_id(collection_locality, &asset_instance)734 .ok_or(XcmExecutorError::InstanceConversionFailed)?;735736 amount = 1;737 map_error = |_| XcmError::FailedToTransactAsset("non-fungible item transfer failed")738 }739 }740741 xcm_ext742 .transfer_item(depositor, &from, &to, token_id, amount, &ZeroBudget)743 .map_err(map_error)?;744745 Ok(what.clone().into())746 }747}748749#[derive(Clone, Copy)]750pub enum CollectionLocality {751 Local(CollectionId),752 Foreign(CollectionId),753}754755impl Deref for CollectionLocality {756 type Target = CollectionId;757758 fn deref(&self) -> &Self::Target {759 match self {760 Self::Local(id) => id,761 Self::Foreign(id) => id,762 }763 }764}765766pub struct CurrencyIdConvert<T: Config>(PhantomData<T>);767impl<T: Config> sp_runtime::traits::Convert<CollectionId, Option<Location>>768 for CurrencyIdConvert<T>769{770 fn convert(collection_id: CollectionId) -> Option<Location> {771 if collection_id == NATIVE_FUNGIBLE_COLLECTION_ID {772 Some(T::SelfLocation::get())773 } else {774 <Pallet<T>>::collection_to_foreign_asset(collection_id)775 .map(|AssetId(location)| location)776 .or_else(|| {777 T::SelfLocation::get()778 .pushed_with_interior(GeneralIndex(collection_id.0.into()))779 .ok()780 })781 }782 }783}784785#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq, TypeInfo, MaxEncodedLen)]786pub enum ForeignCollectionMode {787 NFT,788 Fungible(u8),789}790791impl From<ForeignCollectionMode> for CollectionMode {792 fn from(value: ForeignCollectionMode) -> Self {793 match value {794 ForeignCollectionMode::NFT => Self::NFT,795 ForeignCollectionMode::Fungible(decimals) => Self::Fungible(decimals),796 }797 }798}799800pub struct FreeForAll;801802impl WeightTrader for FreeForAll {803 fn new() -> Self {804 Self805 }806807 fn buy_weight(808 &mut self,809 weight: Weight,810 payment: AssetsInHolding,811 _xcm: &XcmContext,812 ) -> Result<AssetsInHolding, XcmError> {813 log::trace!(target: "fassets::weight", "buy_weight weight: {:?}, payment: {:?}", weight, payment);814 Ok(payment)815 }816}