difftreelog
fix usage of nesting_budget in pallet-unique
in: master
2 files changed
pallets/unique/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//! # Unique Pallet18//!19//! A pallet governing Unique transactions.20//!21//! - [`Config`]22//! - [`Call`]23//! - [`Pallet`]24//!25//! ## Overview26//!27//! The Unique pallet's purpose is to be the primary interface between28//! external users and the inner structure of the Unique chains.29//!30//! It also contains an implementation of [`CollectionHelpers`][`eth`],31//! an Ethereum contract dealing with collection operations.32//!33//! ## Interface34//!35//! ### Dispatchables36//!37//! - `create_collection` - Create a collection of tokens. **Deprecated**, use `create_collection_ex`.38//! - `create_collection_ex` - Create a collection of tokens with explicit parameters.39//! - `destroy_collection` - Destroy a collection if no tokens exist within.40//! - `add_to_allow_list` - Add an address to allow list.41//! - `remove_from_allow_list` - Remove an address from allow list.42//! - `change_collection_owner` - Change the owner of the collection.43//! - `add_collection_admin` - Add an admin to a collection.44//! - `remove_collection_admin` - Remove admin of a collection.45//! - `set_collection_sponsor` - Invite a new collection sponsor.46//! - `confirm_sponsorship` - Confirm own sponsorship of a collection, becoming the sponsor.47//! - `remove_collection_sponsor` - Remove a sponsor from a collection.48//! - `create_item` - Create an item within a collection.49//! - `create_multiple_items` - Create multiple items within a collection.50//! - `set_collection_properties` - Add or change collection properties.51//! - `delete_collection_properties` - Delete specified collection properties.52//! - `set_token_properties` - Add or change token properties.53//! - `delete_token_properties` - Delete token properties.54//! - `set_token_property_permissions` - Add or change token property permissions of a collection.55//! - `create_multiple_items_ex` - Create multiple items within a collection with explicitly specified initial parameters.56//! - `set_transfers_enabled_flag` - Completely allow or disallow transfers for a particular collection.57//! - `burn_item` - Destroy an item.58//! - `burn_from` - Destroy an item on behalf of the owner as a non-owner account.59//! - `transfer` - Change ownership of the token.60//! - `transfer_from` - Change ownership of the token on behalf of the owner as a non-owner account.61//! - `approve` - Allow a non-permissioned address to transfer or burn an item.62//! - `set_collection_limits` - Set specific limits of a collection.63//! - `set_collection_permissions` - Set specific permissions of a collection.64//! - `repartition` - Re-partition a refungible token, while owning all of its parts.6566#![recursion_limit = "1024"]67#![cfg_attr(not(feature = "std"), no_std)]68#![allow(69 clippy::too_many_arguments,70 clippy::unnecessary_mut_passed,71 clippy::unused_unit72)]7374extern crate alloc;7576use frame_support::pallet_prelude::*;77use frame_system::pallet_prelude::*;78pub use pallet::*;79pub mod eth;8081#[cfg(feature = "runtime-benchmarks")]82pub mod benchmarking;83pub mod weights;8485#[frame_support::pallet]86pub mod pallet {87 use frame_support::{88 dispatch::{DispatchErrorWithPostInfo, DispatchResult, PostDispatchInfo},89 ensure, fail,90 storage::Key,91 BoundedVec,92 };93 use frame_system::{ensure_root, ensure_signed};94 use pallet_common::{95 dispatch::{dispatch_tx, CollectionDispatch},96 CollectionHandle, CommonCollectionOperations, CommonWeightInfo, Pallet as PalletCommon,97 RefungibleExtensionsWeightInfo,98 };99 use pallet_evm::account::CrossAccountId;100 use pallet_structure::weights::WeightInfo as StructureWeightInfo;101 use scale_info::TypeInfo;102 use sp_std::{vec, vec::Vec};103 use up_data_structs::{104 budget, CollectionId, CollectionLimits, CollectionMode, CollectionPermissions,105 CreateCollectionData, CreateItemData, CreateItemExData, Property, PropertyKey,106 PropertyKeyPermission, TokenId, COLLECTION_ADMINS_LIMIT, MAX_COLLECTION_DESCRIPTION_LENGTH,107 MAX_COLLECTION_NAME_LENGTH, MAX_COLLECTION_PROPERTIES_SIZE, MAX_PROPERTIES_PER_ITEM,108 MAX_PROPERTY_KEY_LENGTH, MAX_PROPERTY_VALUE_LENGTH, MAX_TOKEN_PREFIX_LENGTH,109 MAX_TOKEN_PROPERTIES_SIZE,110 };111 use weights::WeightInfo;112113 use super::*;114115 /// Errors for the common Unique transactions.116 #[pallet::error]117 pub enum Error<T> {118 /// Decimal_points parameter must be lower than [`up_data_structs::MAX_DECIMAL_POINTS`].119 CollectionDecimalPointLimitExceeded,120 /// Length of items properties must be greater than 0.121 EmptyArgument,122 /// Repertition is only supported by refungible collection.123 RepartitionCalledOnNonRefungibleCollection,124 }125126 /// Configuration trait of this pallet.127 #[pallet::config]128 pub trait Config: frame_system::Config + pallet_common::Config + Sized + TypeInfo {129 /// Weight information for extrinsics in this pallet.130 type WeightInfo: WeightInfo;131132 /// Weight information for common pallet operations.133 type CommonWeightInfo: CommonWeightInfo<Self::CrossAccountId>;134135 type StructureWeightInfo: StructureWeightInfo;136137 /// Weight info information for extra refungible pallet operations.138 type RefungibleExtensionsWeightInfo: RefungibleExtensionsWeightInfo;139 }140141 #[pallet::pallet]142 pub struct Pallet<T>(_);143144 pub type SelfWeightOf<T> = <T as Config>::WeightInfo;145146 // # Used definitions147 //148 // ## User control levels149 //150 // chain-controlled - key is uncontrolled by user151 // i.e autoincrementing index152 // can use non-cryptographic hash153 // real - key is controlled by user154 // but it is hard to generate enough colliding values, i.e owner of signed txs155 // can use non-cryptographic hash156 // controlled - key is completly controlled by users157 // i.e maps with mutable keys158 // should use cryptographic hash159 //160 // ## User control level downgrade reasons161 //162 // ?1 - chain-controlled -> controlled163 // collections/tokens can be destroyed, resulting in massive holes164 // ?2 - chain-controlled -> controlled165 // same as ?1, but can be only added, resulting in easier exploitation166 // ?3 - real -> controlled167 // no confirmation required, so addresses can be easily generated168169 //#region Private members170 /// Used for migrations171 #[pallet::storage]172 pub type ChainVersion<T> = StorageValue<_, u64, ValueQuery>;173 //#endregion174175 //#region Tokens transfer sponosoring rate limit baskets176 /// (Collection id (controlled?2), who created (real))177 /// TODO: Off chain worker should remove from this map when collection gets removed178 #[pallet::storage]179 #[pallet::getter(fn create_item_busket)]180 pub type CreateItemBasket<T: Config> = StorageMap<181 Hasher = Blake2_128Concat,182 Key = (CollectionId, T::AccountId),183 Value = BlockNumberFor<T>,184 QueryKind = OptionQuery,185 >;186 /// Collection id (controlled?2), token id (controlled?2)187 #[pallet::storage]188 #[pallet::getter(fn nft_transfer_basket)]189 pub type NftTransferBasket<T: Config> = StorageDoubleMap<190 Hasher1 = Blake2_128Concat,191 Key1 = CollectionId,192 Hasher2 = Blake2_128Concat,193 Key2 = TokenId,194 Value = BlockNumberFor<T>,195 QueryKind = OptionQuery,196 >;197 /// Collection id (controlled?2), owning user (real)198 #[pallet::storage]199 #[pallet::getter(fn fungible_transfer_basket)]200 pub type FungibleTransferBasket<T: Config> = StorageDoubleMap<201 Hasher1 = Blake2_128Concat,202 Key1 = CollectionId,203 Hasher2 = Twox64Concat,204 Key2 = T::AccountId,205 Value = BlockNumberFor<T>,206 QueryKind = OptionQuery,207 >;208 /// Collection id (controlled?2), token id (controlled?2)209 #[pallet::storage]210 #[pallet::getter(fn refungible_transfer_basket)]211 pub type ReFungibleTransferBasket<T: Config> = StorageNMap<212 Key = (213 Key<Blake2_128Concat, CollectionId>,214 Key<Blake2_128Concat, TokenId>,215 Key<Twox64Concat, T::AccountId>,216 ),217 Value = BlockNumberFor<T>,218 QueryKind = OptionQuery,219 >;220 //#endregion221222 /// Last sponsoring of token property setting // todo:doc rephrase this and the following223 #[pallet::storage]224 #[pallet::getter(fn token_property_basket)]225 pub type TokenPropertyBasket<T: Config> = StorageDoubleMap<226 Hasher1 = Blake2_128Concat,227 Key1 = CollectionId,228 Hasher2 = Blake2_128Concat,229 Key2 = TokenId,230 Value = BlockNumberFor<T>,231 QueryKind = OptionQuery,232 >;233234 /// Last sponsoring of NFT approval in a collection235 #[pallet::storage]236 #[pallet::getter(fn nft_approve_basket)]237 pub type NftApproveBasket<T: Config> = StorageDoubleMap<238 Hasher1 = Blake2_128Concat,239 Key1 = CollectionId,240 Hasher2 = Blake2_128Concat,241 Key2 = TokenId,242 Value = BlockNumberFor<T>,243 QueryKind = OptionQuery,244 >;245 /// Last sponsoring of fungible tokens approval in a collection246 #[pallet::storage]247 #[pallet::getter(fn fungible_approve_basket)]248 pub type FungibleApproveBasket<T: Config> = StorageDoubleMap<249 Hasher1 = Blake2_128Concat,250 Key1 = CollectionId,251 Hasher2 = Twox64Concat,252 Key2 = T::AccountId,253 Value = BlockNumberFor<T>,254 QueryKind = OptionQuery,255 >;256 /// Last sponsoring of RFT approval in a collection257 #[pallet::storage]258 #[pallet::getter(fn refungible_approve_basket)]259 pub type RefungibleApproveBasket<T: Config> = StorageNMap<260 Key = (261 Key<Blake2_128Concat, CollectionId>,262 Key<Blake2_128Concat, TokenId>,263 Key<Twox64Concat, T::AccountId>,264 ),265 Value = BlockNumberFor<T>,266 QueryKind = OptionQuery,267 >;268269 #[pallet::extra_constants]270 impl<T: Config> Pallet<T> {271 /// A maximum number of levels of depth in the token nesting tree.272 fn nesting_budget() -> u32 {273 5274 }275276 /// Maximal length of a collection name.277 fn max_collection_name_length() -> u32 {278 MAX_COLLECTION_NAME_LENGTH279 }280281 /// Maximal length of a collection description.282 fn max_collection_description_length() -> u32 {283 MAX_COLLECTION_DESCRIPTION_LENGTH284 }285286 /// Maximal length of a token prefix.287 fn max_token_prefix_length() -> u32 {288 MAX_TOKEN_PREFIX_LENGTH289 }290291 /// Maximum admins per collection.292 fn collection_admins_limit() -> u32 {293 COLLECTION_ADMINS_LIMIT294 }295296 /// Maximal length of a property key.297 fn max_property_key_length() -> u32 {298 MAX_PROPERTY_KEY_LENGTH299 }300301 /// Maximal length of a property value.302 fn max_property_value_length() -> u32 {303 MAX_PROPERTY_VALUE_LENGTH304 }305306 /// A maximum number of token properties.307 fn max_properties_per_item() -> u32 {308 MAX_PROPERTIES_PER_ITEM309 }310311 /// Maximum size for all collection properties.312 fn max_collection_properties_size() -> u32 {313 MAX_COLLECTION_PROPERTIES_SIZE314 }315316 /// Maximum size of all token properties.317 fn max_token_properties_size() -> u32 {318 MAX_TOKEN_PROPERTIES_SIZE319 }320321 /// Default NFT collection limit.322 fn nft_default_collection_limits() -> CollectionLimits {323 CollectionLimits::with_default_limits(CollectionMode::NFT)324 }325326 /// Default RFT collection limit.327 fn rft_default_collection_limits() -> CollectionLimits {328 CollectionLimits::with_default_limits(CollectionMode::ReFungible)329 }330331 /// Default FT collection limit.332 fn ft_default_collection_limits() -> CollectionLimits {333 CollectionLimits::with_default_limits(CollectionMode::Fungible(0))334 }335 }336337 /// Type alias to Pallet, to be used by construct_runtime.338 #[pallet::call]339 impl<T: Config> Pallet<T> {340 /// Create a collection of tokens.341 ///342 /// Each Token may have multiple properties encoded as an array of bytes343 /// of certain length. The initial owner of the collection is set344 /// to the address that signed the transaction and can be changed later.345 ///346 /// Prefer the more advanced [`create_collection_ex`][`Pallet::create_collection_ex`] instead.347 ///348 /// # Permissions349 ///350 /// * Anyone - becomes the owner of the new collection.351 ///352 /// # Arguments353 ///354 /// * `collection_name`: Wide-character string with collection name355 /// (limit [`MAX_COLLECTION_NAME_LENGTH`]).356 /// * `collection_description`: Wide-character string with collection description357 /// (limit [`MAX_COLLECTION_DESCRIPTION_LENGTH`]).358 /// * `token_prefix`: Byte string containing the token prefix to mark a collection359 /// to which a token belongs (limit [`MAX_TOKEN_PREFIX_LENGTH`]).360 /// * `mode`: Type of items stored in the collection and type dependent data.361 ///362 /// returns collection ID363 ///364 /// Deprecated: `create_collection_ex` is more up-to-date and advanced, prefer it instead.365 #[pallet::call_index(0)]366 #[pallet::weight(<SelfWeightOf<T>>::create_collection())]367 pub fn create_collection(368 origin: OriginFor<T>,369 collection_name: BoundedVec<u16, ConstU32<MAX_COLLECTION_NAME_LENGTH>>,370 collection_description: BoundedVec<u16, ConstU32<MAX_COLLECTION_DESCRIPTION_LENGTH>>,371 token_prefix: BoundedVec<u8, ConstU32<MAX_TOKEN_PREFIX_LENGTH>>,372 mode: CollectionMode,373 ) -> DispatchResult {374 let data: CreateCollectionData<T::CrossAccountId> = CreateCollectionData {375 name: collection_name,376 description: collection_description,377 token_prefix,378 mode,379 ..Default::default()380 };381 Self::create_collection_ex(origin, data)382 }383384 /// Create a collection with explicit parameters.385 ///386 /// Prefer it to the deprecated [`create_collection`][`Pallet::create_collection`] method.387 ///388 /// # Permissions389 ///390 /// * Anyone - becomes the owner of the new collection.391 ///392 /// # Arguments393 ///394 /// * `data`: Explicit data of a collection used for its creation.395 #[pallet::call_index(1)]396 #[pallet::weight(<SelfWeightOf<T>>::create_collection())]397 pub fn create_collection_ex(398 origin: OriginFor<T>,399 data: CreateCollectionData<T::CrossAccountId>,400 ) -> DispatchResult {401 let sender = ensure_signed(origin)?;402403 // =========404 let sender = T::CrossAccountId::from_sub(sender);405 let _id = T::CollectionDispatch::create(sender.clone(), sender, data)?;406407 Ok(())408 }409410 /// Destroy a collection if no tokens exist within.411 ///412 /// # Permissions413 ///414 /// * Collection owner415 ///416 /// # Arguments417 ///418 /// * `collection_id`: Collection to destroy.419 #[pallet::call_index(2)]420 #[pallet::weight(<SelfWeightOf<T>>::destroy_collection())]421 pub fn destroy_collection(422 origin: OriginFor<T>,423 collection_id: CollectionId,424 ) -> DispatchResult {425 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);426427 Self::destroy_collection_internal(sender, collection_id)428 }429430 /// Add an address to allow list.431 ///432 /// # Permissions433 ///434 /// * Collection owner435 /// * Collection admin436 ///437 /// # Arguments438 ///439 /// * `collection_id`: ID of the modified collection.440 /// * `address`: ID of the address to be added to the allowlist.441 #[pallet::call_index(3)]442 #[pallet::weight(<SelfWeightOf<T>>::add_to_allow_list())]443 pub fn add_to_allow_list(444 origin: OriginFor<T>,445 collection_id: CollectionId,446 address: T::CrossAccountId,447 ) -> DispatchResult {448 if collection_id == pallet_common::NATIVE_FUNGIBLE_COLLECTION_ID {449 fail!(<pallet_common::Error<T>>::UnsupportedOperation);450 }451452 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);453 let collection = <CollectionHandle<T>>::try_get(collection_id)?;454 collection.check_is_internal()?;455456 <PalletCommon<T>>::toggle_allowlist(&collection, &sender, &address, true)?;457458 Ok(())459 }460461 /// Remove an address from allow list.462 ///463 /// # Permissions464 ///465 /// * Collection owner466 /// * Collection admin467 ///468 /// # Arguments469 ///470 /// * `collection_id`: ID of the modified collection.471 /// * `address`: ID of the address to be removed from the allowlist.472 #[pallet::call_index(4)]473 #[pallet::weight(<SelfWeightOf<T>>::remove_from_allow_list())]474 pub fn remove_from_allow_list(475 origin: OriginFor<T>,476 collection_id: CollectionId,477 address: T::CrossAccountId,478 ) -> DispatchResult {479 if collection_id == pallet_common::NATIVE_FUNGIBLE_COLLECTION_ID {480 fail!(<pallet_common::Error<T>>::UnsupportedOperation);481 }482483 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);484 let collection = <CollectionHandle<T>>::try_get(collection_id)?;485 collection.check_is_internal()?;486487 <PalletCommon<T>>::toggle_allowlist(&collection, &sender, &address, false)?;488489 Ok(())490 }491492 /// Change the owner of the collection.493 ///494 /// # Permissions495 ///496 /// * Collection owner497 ///498 /// # Arguments499 ///500 /// * `collection_id`: ID of the modified collection.501 /// * `new_owner`: ID of the account that will become the owner.502 #[pallet::call_index(5)]503 #[pallet::weight(<SelfWeightOf<T>>::change_collection_owner())]504 pub fn change_collection_owner(505 origin: OriginFor<T>,506 collection_id: CollectionId,507 new_owner: T::AccountId,508 ) -> DispatchResult {509 if collection_id == pallet_common::NATIVE_FUNGIBLE_COLLECTION_ID {510 fail!(<pallet_common::Error<T>>::UnsupportedOperation);511 }512 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);513 let new_owner = T::CrossAccountId::from_sub(new_owner);514 let mut target_collection = <CollectionHandle<T>>::try_get(collection_id)?;515 target_collection.change_owner(sender, new_owner)516 }517518 /// Add an admin to a collection.519 ///520 /// NFT Collection can be controlled by multiple admin addresses521 /// (some which can also be servers, for example). Admins can issue522 /// and burn NFTs, as well as add and remove other admins,523 /// but cannot change NFT or Collection ownership.524 ///525 /// # Permissions526 ///527 /// * Collection owner528 /// * Collection admin529 ///530 /// # Arguments531 ///532 /// * `collection_id`: ID of the Collection to add an admin for.533 /// * `new_admin`: Address of new admin to add.534 #[pallet::call_index(6)]535 #[pallet::weight(<SelfWeightOf<T>>::add_collection_admin())]536 pub fn add_collection_admin(537 origin: OriginFor<T>,538 collection_id: CollectionId,539 new_admin_id: T::CrossAccountId,540 ) -> DispatchResult {541 if collection_id == pallet_common::NATIVE_FUNGIBLE_COLLECTION_ID {542 fail!(<pallet_common::Error<T>>::UnsupportedOperation);543 }544 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);545 let collection = <CollectionHandle<T>>::try_get(collection_id)?;546 <PalletCommon<T>>::toggle_admin(&collection, &sender, &new_admin_id, true)547 }548549 /// Remove admin of a collection.550 ///551 /// An admin address can remove itself. List of admins may become empty,552 /// in which case only Collection Owner will be able to add an Admin.553 ///554 /// # Permissions555 ///556 /// * Collection owner557 /// * Collection admin558 ///559 /// # Arguments560 ///561 /// * `collection_id`: ID of the collection to remove the admin for.562 /// * `account_id`: Address of the admin to remove.563 #[pallet::call_index(7)]564 #[pallet::weight(<SelfWeightOf<T>>::remove_collection_admin())]565 pub fn remove_collection_admin(566 origin: OriginFor<T>,567 collection_id: CollectionId,568 account_id: T::CrossAccountId,569 ) -> DispatchResult {570 if collection_id == pallet_common::NATIVE_FUNGIBLE_COLLECTION_ID {571 fail!(<pallet_common::Error<T>>::UnsupportedOperation);572 }573 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);574 let collection = <CollectionHandle<T>>::try_get(collection_id)?;575 <PalletCommon<T>>::toggle_admin(&collection, &sender, &account_id, false)576 }577578 /// Set (invite) a new collection sponsor.579 ///580 /// If successful, confirmation from the sponsor-to-be will be pending.581 ///582 /// # Permissions583 ///584 /// * Collection owner585 /// * Collection admin586 ///587 /// # Arguments588 ///589 /// * `collection_id`: ID of the modified collection.590 /// * `new_sponsor`: ID of the account of the sponsor-to-be.591 #[pallet::call_index(8)]592 #[pallet::weight(<SelfWeightOf<T>>::set_collection_sponsor())]593 pub fn set_collection_sponsor(594 origin: OriginFor<T>,595 collection_id: CollectionId,596 new_sponsor: T::AccountId,597 ) -> DispatchResult {598 if collection_id == pallet_common::NATIVE_FUNGIBLE_COLLECTION_ID {599 fail!(<pallet_common::Error<T>>::UnsupportedOperation);600 }601 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);602 let mut target_collection = <CollectionHandle<T>>::try_get(collection_id)?;603 target_collection.set_sponsor(&sender, new_sponsor.clone())604 }605606 /// Confirm own sponsorship of a collection, becoming the sponsor.607 ///608 /// An invitation must be pending, see [`set_collection_sponsor`][`Pallet::set_collection_sponsor`].609 /// Sponsor can pay the fees of a transaction instead of the sender,610 /// but only within specified limits.611 ///612 /// # Permissions613 ///614 /// * Sponsor-to-be615 ///616 /// # Arguments617 ///618 /// * `collection_id`: ID of the collection with the pending sponsor.619 #[pallet::call_index(9)]620 #[pallet::weight(<SelfWeightOf<T>>::confirm_sponsorship())]621 pub fn confirm_sponsorship(622 origin: OriginFor<T>,623 collection_id: CollectionId,624 ) -> DispatchResult {625 if collection_id == pallet_common::NATIVE_FUNGIBLE_COLLECTION_ID {626 fail!(<pallet_common::Error<T>>::UnsupportedOperation);627 }628 let sender = ensure_signed(origin)?;629 let mut target_collection = <CollectionHandle<T>>::try_get(collection_id)?;630 target_collection.confirm_sponsorship(&sender)631 }632633 /// Remove a collection's a sponsor, making everyone pay for their own transactions.634 ///635 /// # Permissions636 ///637 /// * Collection owner638 ///639 /// # Arguments640 ///641 /// * `collection_id`: ID of the collection with the sponsor to remove.642 #[pallet::call_index(10)]643 #[pallet::weight(<SelfWeightOf<T>>::remove_collection_sponsor())]644 pub fn remove_collection_sponsor(645 origin: OriginFor<T>,646 collection_id: CollectionId,647 ) -> DispatchResult {648 if collection_id == pallet_common::NATIVE_FUNGIBLE_COLLECTION_ID {649 fail!(<pallet_common::Error<T>>::UnsupportedOperation);650 }651 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);652 let mut target_collection = <CollectionHandle<T>>::try_get(collection_id)?;653 target_collection.remove_sponsor(&sender)654 }655656 /// Mint an item within a collection.657 ///658 /// A collection must exist first, see [`create_collection_ex`][`Pallet::create_collection_ex`].659 ///660 /// # Permissions661 ///662 /// * Collection owner663 /// * Collection admin664 /// * Anyone if665 /// * Allow List is enabled, and666 /// * Address is added to allow list, and667 /// * MintPermission is enabled (see [`set_collection_permissions`][`Pallet::set_collection_permissions`])668 ///669 /// # Arguments670 ///671 /// * `collection_id`: ID of the collection to which an item would belong.672 /// * `owner`: Address of the initial owner of the item.673 /// * `data`: Token data describing the item to store on chain.674 #[pallet::call_index(11)]675 #[pallet::weight(T::CommonWeightInfo::create_item(data) + <Pallet<T>>::nesting_budget_predispatch_weight())]676 pub fn create_item(677 origin: OriginFor<T>,678 collection_id: CollectionId,679 owner: T::CrossAccountId,680 data: CreateItemData,681 ) -> DispatchResultWithPostInfo {682 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);683 let budget = Self::structure_nesting_budget();684685 Self::dispatch_tx_with_nesting_budget(collection_id, &budget, |d| {686 d.create_item(sender, owner, data, &budget)687 })688 }689690 /// Create multiple items within a collection.691 ///692 /// A collection must exist first, see [`create_collection_ex`][`Pallet::create_collection_ex`].693 ///694 /// # Permissions695 ///696 /// * Collection owner697 /// * Collection admin698 /// * Anyone if699 /// * Allow List is enabled, and700 /// * Address is added to the allow list, and701 /// * MintPermission is enabled (see [`set_collection_permissions`][`Pallet::set_collection_permissions`])702 ///703 /// # Arguments704 ///705 /// * `collection_id`: ID of the collection to which the tokens would belong.706 /// * `owner`: Address of the initial owner of the tokens.707 /// * `items_data`: Vector of data describing each item to be created.708 #[pallet::call_index(12)]709 #[pallet::weight(T::CommonWeightInfo::create_multiple_items(items_data) + <Pallet<T>>::nesting_budget_predispatch_weight())]710 pub fn create_multiple_items(711 origin: OriginFor<T>,712 collection_id: CollectionId,713 owner: T::CrossAccountId,714 items_data: Vec<CreateItemData>,715 ) -> DispatchResultWithPostInfo {716 ensure!(!items_data.is_empty(), Error::<T>::EmptyArgument);717 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);718 let budget = Self::structure_nesting_budget();719720 Self::dispatch_tx_with_nesting_budget(collection_id, &budget, |d| {721 d.create_multiple_items(sender, owner, items_data, &budget)722 })723 }724725 /// Add or change collection properties.726 ///727 /// # Permissions728 ///729 /// * Collection owner730 /// * Collection admin731 ///732 /// # Arguments733 ///734 /// * `collection_id`: ID of the modified collection.735 /// * `properties`: Vector of key-value pairs stored as the collection's metadata.736 /// Keys support Latin letters, `-`, `_`, and `.` as symbols.737 #[pallet::call_index(13)]738 #[pallet::weight(T::CommonWeightInfo::set_collection_properties(properties.len() as u32))]739 pub fn set_collection_properties(740 origin: OriginFor<T>,741 collection_id: CollectionId,742 properties: Vec<Property>,743 ) -> DispatchResultWithPostInfo {744 ensure!(!properties.is_empty(), Error::<T>::EmptyArgument);745746 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);747748 dispatch_tx::<T, _>(collection_id, |d| {749 d.set_collection_properties(sender, properties)750 })751 }752753 /// Delete specified collection properties.754 ///755 /// # Permissions756 ///757 /// * Collection Owner758 /// * Collection Admin759 ///760 /// # Arguments761 ///762 /// * `collection_id`: ID of the modified collection.763 /// * `property_keys`: Vector of keys of the properties to be deleted.764 /// Keys support Latin letters, `-`, `_`, and `.` as symbols.765 #[pallet::call_index(14)]766 #[pallet::weight(T::CommonWeightInfo::delete_collection_properties(property_keys.len() as u32))]767 pub fn delete_collection_properties(768 origin: OriginFor<T>,769 collection_id: CollectionId,770 property_keys: Vec<PropertyKey>,771 ) -> DispatchResultWithPostInfo {772 ensure!(!property_keys.is_empty(), Error::<T>::EmptyArgument);773774 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);775776 dispatch_tx::<T, _>(collection_id, |d| {777 d.delete_collection_properties(&sender, property_keys)778 })779 }780781 /// Add or change token properties according to collection's permissions.782 /// Currently properties only work with NFTs.783 ///784 /// # Permissions785 ///786 /// * Depends on collection's token property permissions and specified property mutability:787 /// * Collection owner788 /// * Collection admin789 /// * Token owner790 ///791 /// See [`set_token_property_permissions`][`Pallet::set_token_property_permissions`].792 ///793 /// # Arguments794 ///795 /// * `collection_id: ID of the collection to which the token belongs.796 /// * `token_id`: ID of the modified token.797 /// * `properties`: Vector of key-value pairs stored as the token's metadata.798 /// Keys support Latin letters, `-`, `_`, and `.` as symbols.799 #[pallet::call_index(15)]800 #[pallet::weight(T::CommonWeightInfo::set_token_properties(properties.len() as u32) + <Pallet<T>>::nesting_budget_predispatch_weight())]801 pub fn set_token_properties(802 origin: OriginFor<T>,803 collection_id: CollectionId,804 token_id: TokenId,805 properties: Vec<Property>,806 ) -> DispatchResultWithPostInfo {807 ensure!(!properties.is_empty(), Error::<T>::EmptyArgument);808809 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);810 let budget = Self::structure_nesting_budget();811812 Self::dispatch_tx_with_nesting_budget(collection_id, &budget, |d| {813 d.set_token_properties(sender, token_id, properties, &budget)814 })815 }816817 /// Delete specified token properties. Currently properties only work with NFTs.818 ///819 /// # Permissions820 ///821 /// * Depends on collection's token property permissions and specified property mutability:822 /// * Collection owner823 /// * Collection admin824 /// * Token owner825 ///826 /// # Arguments827 ///828 /// * `collection_id`: ID of the collection to which the token belongs.829 /// * `token_id`: ID of the modified token.830 /// * `property_keys`: Vector of keys of the properties to be deleted.831 /// Keys support Latin letters, `-`, `_`, and `.` as symbols.832 #[pallet::call_index(16)]833 #[pallet::weight(T::CommonWeightInfo::delete_token_properties(property_keys.len() as u32) + <Pallet<T>>::nesting_budget_predispatch_weight())]834 pub fn delete_token_properties(835 origin: OriginFor<T>,836 collection_id: CollectionId,837 token_id: TokenId,838 property_keys: Vec<PropertyKey>,839 ) -> DispatchResultWithPostInfo {840 ensure!(!property_keys.is_empty(), Error::<T>::EmptyArgument);841842 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);843 let budget = Self::structure_nesting_budget();844845 Self::dispatch_tx_with_nesting_budget(collection_id, &budget, |d| {846 d.delete_token_properties(sender, token_id, property_keys, &budget)847 })848 }849850 /// Add or change token property permissions of a collection.851 ///852 /// Without a permission for a particular key, a property with that key853 /// cannot be created in a token.854 ///855 /// # Permissions856 ///857 /// * Collection owner858 /// * Collection admin859 ///860 /// # Arguments861 ///862 /// * `collection_id`: ID of the modified collection.863 /// * `property_permissions`: Vector of permissions for property keys.864 /// Keys support Latin letters, `-`, `_`, and `.` as symbols.865 #[pallet::call_index(17)]866 #[pallet::weight(T::CommonWeightInfo::set_token_property_permissions(property_permissions.len() as u32))]867 pub fn set_token_property_permissions(868 origin: OriginFor<T>,869 collection_id: CollectionId,870 property_permissions: Vec<PropertyKeyPermission>,871 ) -> DispatchResultWithPostInfo {872 ensure!(!property_permissions.is_empty(), Error::<T>::EmptyArgument);873874 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);875876 dispatch_tx::<T, _>(collection_id, |d| {877 d.set_token_property_permissions(&sender, property_permissions)878 })879 }880881 /// Create multiple items within a collection with explicitly specified initial parameters.882 ///883 /// # Permissions884 ///885 /// * Collection owner886 /// * Collection admin887 /// * Anyone if888 /// * Allow List is enabled, and889 /// * Address is added to allow list, and890 /// * MintPermission is enabled (see [`set_collection_permissions`][`Pallet::set_collection_permissions`])891 ///892 /// # Arguments893 ///894 /// * `collection_id`: ID of the collection to which the tokens would belong.895 /// * `data`: Explicit item creation data.896 #[pallet::call_index(18)]897 #[pallet::weight(T::CommonWeightInfo::create_multiple_items_ex(data) + <Pallet<T>>::nesting_budget_predispatch_weight())]898 pub fn create_multiple_items_ex(899 origin: OriginFor<T>,900 collection_id: CollectionId,901 data: CreateItemExData<T::CrossAccountId>,902 ) -> DispatchResultWithPostInfo {903 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);904 let budget = Self::structure_nesting_budget();905906 Self::dispatch_tx_with_nesting_budget(collection_id, &budget, |d| {907 d.create_multiple_items_ex(sender, data, &budget)908 })909 }910911 /// Completely allow or disallow transfers for a particular collection.912 ///913 /// # Permissions914 ///915 /// * Collection owner916 ///917 /// # Arguments918 ///919 /// * `collection_id`: ID of the collection.920 /// * `value`: New value of the flag, are transfers allowed?921 #[pallet::call_index(19)]922 #[pallet::weight(<SelfWeightOf<T>>::set_transfers_enabled_flag())]923 pub fn set_transfers_enabled_flag(924 origin: OriginFor<T>,925 collection_id: CollectionId,926 value: bool,927 ) -> DispatchResult {928 if collection_id == pallet_common::NATIVE_FUNGIBLE_COLLECTION_ID {929 fail!(<pallet_common::Error<T>>::UnsupportedOperation);930 }931 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);932 let mut target_collection = <CollectionHandle<T>>::try_get(collection_id)?;933 target_collection.check_is_internal()?;934 target_collection.check_is_owner(&sender)?;935936 // =========937938 target_collection.limits.transfers_enabled = Some(value);939 target_collection.save()940 }941942 /// Destroy an item.943 ///944 /// # Permissions945 ///946 /// * Collection owner947 /// * Collection admin948 /// * Current item owner949 ///950 /// # Arguments951 ///952 /// * `collection_id`: ID of the collection to which the item belongs.953 /// * `item_id`: ID of item to burn.954 /// * `value`: Number of pieces of the item to destroy.955 /// * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.956 /// * Fungible Mode: The desired number of pieces to burn.957 /// * Re-Fungible Mode: The desired number of pieces to burn.958 #[pallet::call_index(20)]959 #[pallet::weight(T::CommonWeightInfo::burn_item())]960 pub fn burn_item(961 origin: OriginFor<T>,962 collection_id: CollectionId,963 item_id: TokenId,964 value: u128,965 ) -> DispatchResultWithPostInfo {966 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);967968 let post_info =969 dispatch_tx::<T, _>(collection_id, |d| d.burn_item(sender, item_id, value))?;970 if value == 1 {971 <NftTransferBasket<T>>::remove(collection_id, item_id);972 <NftApproveBasket<T>>::remove(collection_id, item_id);973 }974 // Those maps should be cleared only if token disappears completly, need to move this part of logic to pallets?975 // <FungibleApproveBasket<T>>::remove(collection_id, sender.as_sub());976 // <RefungibleApproveBasket<T>>::remove((collection_id, item_id, sender.as_sub()));977 Ok(post_info)978 }979980 /// Destroy a token on behalf of the owner as a non-owner account.981 ///982 /// See also: [`approve`][`Pallet::approve`].983 ///984 /// After this method executes, one approval is removed from the total so that985 /// the approved address will not be able to transfer this item again from this owner.986 ///987 /// # Permissions988 ///989 /// * Collection owner990 /// * Collection admin991 /// * Current token owner992 /// * Address approved by current item owner993 ///994 /// # Arguments995 ///996 /// * `from`: The owner of the burning item.997 /// * `collection_id`: ID of the collection to which the item belongs.998 /// * `item_id`: ID of item to burn.999 /// * `value`: Number of pieces to burn.1000 /// * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.1001 /// * Fungible Mode: The desired number of pieces to burn.1002 /// * Re-Fungible Mode: The desired number of pieces to burn.1003 #[pallet::call_index(21)]1004 #[pallet::weight(T::CommonWeightInfo::burn_from() + <Pallet<T>>::nesting_budget_predispatch_weight())]1005 pub fn burn_from(1006 origin: OriginFor<T>,1007 collection_id: CollectionId,1008 from: T::CrossAccountId,1009 item_id: TokenId,1010 value: u128,1011 ) -> DispatchResultWithPostInfo {1012 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1013 let budget = Self::structure_nesting_budget();10141015 Self::dispatch_tx_with_nesting_budget(collection_id, &budget, |d| {1016 d.burn_from(sender, from, item_id, value, &budget)1017 })1018 }10191020 /// Change ownership of the token.1021 ///1022 /// # Permissions1023 ///1024 /// * Collection owner1025 /// * Collection admin1026 /// * Current token owner1027 ///1028 /// # Arguments1029 ///1030 /// * `recipient`: Address of token recipient.1031 /// * `collection_id`: ID of the collection the item belongs to.1032 /// * `item_id`: ID of the item.1033 /// * Non-Fungible Mode: Required.1034 /// * Fungible Mode: Ignored.1035 /// * Re-Fungible Mode: Required.1036 ///1037 /// * `value`: Amount to transfer.1038 /// * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.1039 /// * Fungible Mode: The desired number of pieces to transfer.1040 /// * Re-Fungible Mode: The desired number of pieces to transfer.1041 #[pallet::call_index(22)]1042 #[pallet::weight(T::CommonWeightInfo::transfer() + <Pallet<T>>::nesting_budget_predispatch_weight())]1043 pub fn transfer(1044 origin: OriginFor<T>,1045 recipient: T::CrossAccountId,1046 collection_id: CollectionId,1047 item_id: TokenId,1048 value: u128,1049 ) -> DispatchResultWithPostInfo {1050 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1051 let budget = Self::structure_nesting_budget();10521053 Self::dispatch_tx_with_nesting_budget(collection_id, &budget, |d| {1054 d.transfer(sender, recipient, item_id, value, &budget)1055 })1056 }10571058 /// Allow a non-permissioned address to transfer or burn an item.1059 ///1060 /// # Permissions1061 ///1062 /// * Collection owner1063 /// * Collection admin1064 /// * Current item owner1065 ///1066 /// # Arguments1067 ///1068 /// * `spender`: Account to be approved to make specific transactions on non-owned tokens.1069 /// * `collection_id`: ID of the collection the item belongs to.1070 /// * `item_id`: ID of the item transactions on which are now approved.1071 /// * `amount`: Number of pieces of the item approved for a transaction (maximum of 1 for NFTs).1072 /// Set to 0 to revoke the approval.1073 #[pallet::call_index(23)]1074 #[pallet::weight(T::CommonWeightInfo::approve())]1075 pub fn approve(1076 origin: OriginFor<T>,1077 spender: T::CrossAccountId,1078 collection_id: CollectionId,1079 item_id: TokenId,1080 amount: u128,1081 ) -> DispatchResultWithPostInfo {1082 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);10831084 dispatch_tx::<T, _>(collection_id, |d| {1085 d.approve(sender, spender, item_id, amount)1086 })1087 }10881089 /// Allow a non-permissioned address to transfer or burn an item from owner's eth mirror.1090 ///1091 /// # Permissions1092 ///1093 /// * Collection owner1094 /// * Collection admin1095 /// * Current item owner1096 ///1097 /// # Arguments1098 ///1099 /// * `from`: Owner's account eth mirror1100 /// * `to`: Account to be approved to make specific transactions on non-owned tokens.1101 /// * `collection_id`: ID of the collection the item belongs to.1102 /// * `item_id`: ID of the item transactions on which are now approved.1103 /// * `amount`: Number of pieces of the item approved for a transaction (maximum of 1 for NFTs).1104 /// Set to 0 to revoke the approval.1105 #[pallet::call_index(24)]1106 #[pallet::weight(T::CommonWeightInfo::approve_from())]1107 pub fn approve_from(1108 origin: OriginFor<T>,1109 from: T::CrossAccountId,1110 to: T::CrossAccountId,1111 collection_id: CollectionId,1112 item_id: TokenId,1113 amount: u128,1114 ) -> DispatchResultWithPostInfo {1115 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);11161117 dispatch_tx::<T, _>(collection_id, |d| {1118 d.approve_from(sender, from, to, item_id, amount)1119 })1120 }11211122 /// Change ownership of an item on behalf of the owner as a non-owner account.1123 ///1124 /// See the [`approve`][`Pallet::approve`] method for additional information.1125 ///1126 /// After this method executes, one approval is removed from the total so that1127 /// the approved address will not be able to transfer this item again from this owner.1128 ///1129 /// # Permissions1130 ///1131 /// * Collection owner1132 /// * Collection admin1133 /// * Current item owner1134 /// * Address approved by current item owner1135 ///1136 /// # Arguments1137 ///1138 /// * `from`: Address that currently owns the token.1139 /// * `recipient`: Address of the new token-owner-to-be.1140 /// * `collection_id`: ID of the collection the item.1141 /// * `item_id`: ID of the item to be transferred.1142 /// * `value`: Amount to transfer.1143 /// * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.1144 /// * Fungible Mode: The desired number of pieces to transfer.1145 /// * Re-Fungible Mode: The desired number of pieces to transfer.1146 #[pallet::call_index(25)]1147 #[pallet::weight(T::CommonWeightInfo::transfer_from() + <Pallet<T>>::nesting_budget_predispatch_weight())]1148 pub fn transfer_from(1149 origin: OriginFor<T>,1150 from: T::CrossAccountId,1151 recipient: T::CrossAccountId,1152 collection_id: CollectionId,1153 item_id: TokenId,1154 value: u128,1155 ) -> DispatchResultWithPostInfo {1156 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1157 let budget = Self::structure_nesting_budget();11581159 Self::dispatch_tx_with_nesting_budget(collection_id, &budget, |d| {1160 d.transfer_from(sender, from, recipient, item_id, value, &budget)1161 })1162 }11631164 /// Set specific limits of a collection. Empty, or None fields mean chain default.1165 ///1166 /// # Permissions1167 ///1168 /// * Collection owner1169 /// * Collection admin1170 ///1171 /// # Arguments1172 ///1173 /// * `collection_id`: ID of the modified collection.1174 /// * `new_limit`: New limits of the collection. Fields that are not set (None)1175 /// will not overwrite the old ones.1176 #[pallet::call_index(26)]1177 #[pallet::weight(<SelfWeightOf<T>>::set_collection_limits())]1178 pub fn set_collection_limits(1179 origin: OriginFor<T>,1180 collection_id: CollectionId,1181 new_limit: CollectionLimits,1182 ) -> DispatchResult {1183 if collection_id == pallet_common::NATIVE_FUNGIBLE_COLLECTION_ID {1184 fail!(<pallet_common::Error<T>>::UnsupportedOperation);1185 }1186 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1187 let mut target_collection = <CollectionHandle<T>>::try_get(collection_id)?;1188 <PalletCommon<T>>::update_limits(&sender, &mut target_collection, new_limit)1189 }11901191 /// Set specific permissions of a collection. Empty, or None fields mean chain default.1192 ///1193 /// # Permissions1194 ///1195 /// * Collection owner1196 /// * Collection admin1197 ///1198 /// # Arguments1199 ///1200 /// * `collection_id`: ID of the modified collection.1201 /// * `new_permission`: New permissions of the collection. Fields that are not set (None)1202 /// will not overwrite the old ones.1203 #[pallet::call_index(27)]1204 #[pallet::weight(<SelfWeightOf<T>>::set_collection_limits())]1205 pub fn set_collection_permissions(1206 origin: OriginFor<T>,1207 collection_id: CollectionId,1208 new_permission: CollectionPermissions,1209 ) -> DispatchResult {1210 if collection_id == pallet_common::NATIVE_FUNGIBLE_COLLECTION_ID {1211 fail!(<pallet_common::Error<T>>::UnsupportedOperation);1212 }1213 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1214 let mut target_collection = <CollectionHandle<T>>::try_get(collection_id)?;1215 <PalletCommon<T>>::update_permissions(&sender, &mut target_collection, new_permission)1216 }12171218 /// Re-partition a refungible token, while owning all of its parts/pieces.1219 ///1220 /// # Permissions1221 ///1222 /// * Token owner (must own every part)1223 ///1224 /// # Arguments1225 ///1226 /// * `collection_id`: ID of the collection the RFT belongs to.1227 /// * `token_id`: ID of the RFT.1228 /// * `amount`: New number of parts/pieces into which the token shall be partitioned.1229 #[pallet::call_index(28)]1230 #[pallet::weight(T::RefungibleExtensionsWeightInfo::repartition())]1231 pub fn repartition(1232 origin: OriginFor<T>,1233 collection_id: CollectionId,1234 token_id: TokenId,1235 amount: u128,1236 ) -> DispatchResultWithPostInfo {1237 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1238 dispatch_tx::<T, _>(collection_id, |d| {1239 if let Some(refungible_extensions) = d.refungible_extensions() {1240 refungible_extensions.repartition(&sender, token_id, amount)1241 } else {1242 fail!(<Error<T>>::RepartitionCalledOnNonRefungibleCollection)1243 }1244 })1245 }12461247 /// Sets or unsets the approval of a given operator.1248 ///1249 /// The `operator` is allowed to transfer all tokens of the `owner` on their behalf.1250 ///1251 /// # Arguments1252 ///1253 /// * `owner`: Token owner1254 /// * `operator`: Operator1255 /// * `approve`: Should operator status be granted or revoked?1256 #[pallet::call_index(29)]1257 #[pallet::weight(T::CommonWeightInfo::set_allowance_for_all())]1258 pub fn set_allowance_for_all(1259 origin: OriginFor<T>,1260 collection_id: CollectionId,1261 operator: T::CrossAccountId,1262 approve: bool,1263 ) -> DispatchResultWithPostInfo {1264 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1265 dispatch_tx::<T, _>(collection_id, |d| {1266 d.set_allowance_for_all(sender, operator, approve)1267 })1268 }12691270 /// Repairs a collection if the data was somehow corrupted.1271 ///1272 /// # Arguments1273 ///1274 /// * `collection_id`: ID of the collection to repair.1275 #[pallet::call_index(30)]1276 #[pallet::weight(<SelfWeightOf<T>>::force_repair_collection())]1277 pub fn force_repair_collection(1278 origin: OriginFor<T>,1279 collection_id: CollectionId,1280 ) -> DispatchResult {1281 if collection_id == pallet_common::NATIVE_FUNGIBLE_COLLECTION_ID {1282 fail!(<pallet_common::Error<T>>::UnsupportedOperation);1283 }1284 ensure_root(origin)?;1285 <PalletCommon<T>>::repair_collection(collection_id)1286 }12871288 /// Repairs a token if the data was somehow corrupted.1289 ///1290 /// # Arguments1291 ///1292 /// * `collection_id`: ID of the collection the item belongs to.1293 /// * `item_id`: ID of the item.1294 #[pallet::call_index(31)]1295 #[pallet::weight(T::CommonWeightInfo::force_repair_item())]1296 pub fn force_repair_item(1297 origin: OriginFor<T>,1298 collection_id: CollectionId,1299 item_id: TokenId,1300 ) -> DispatchResultWithPostInfo {1301 ensure_root(origin)?;1302 dispatch_tx::<T, _>(collection_id, |d| d.repair_item(item_id))1303 }1304 }13051306 impl<T: Config> Pallet<T> {1307 /// Force set `sponsor` for `collection`.1308 ///1309 /// Differs from [`set_collection_sponsor`][`Pallet::set_collection_sponsor`] in that confirmation1310 /// from the `sponsor` is not required.1311 ///1312 /// # Arguments1313 ///1314 /// * `sponsor`: ID of the account of the sponsor-to-be.1315 /// * `collection_id`: ID of the modified collection.1316 pub fn force_set_sponsor(1317 sponsor: T::AccountId,1318 collection_id: CollectionId,1319 ) -> DispatchResult {1320 let mut target_collection = <CollectionHandle<T>>::try_get(collection_id)?;1321 target_collection.force_set_sponsor(sponsor)1322 }13231324 /// Force remove `sponsor` for `collection`.1325 ///1326 /// Differs from `remove_sponsor` in that1327 /// it doesn't require consent from the `owner` of the collection.1328 ///1329 /// # Arguments1330 ///1331 /// * `collection_id`: ID of the modified collection.1332 pub fn force_remove_collection_sponsor(collection_id: CollectionId) -> DispatchResult {1333 let mut target_collection = <CollectionHandle<T>>::try_get(collection_id)?;1334 target_collection.force_remove_sponsor()1335 }13361337 #[inline(always)]1338 pub(crate) fn destroy_collection_internal(1339 sender: T::CrossAccountId,1340 collection_id: CollectionId,1341 ) -> DispatchResult {1342 T::CollectionDispatch::destroy(sender, collection_id)?;13431344 // TODO: basket cleanup should be moved elsewhere1345 // Maybe runtime dispatch.rs should perform it?13461347 let _ = <NftTransferBasket<T>>::clear_prefix(collection_id, u32::MAX, None);1348 let _ = <FungibleTransferBasket<T>>::clear_prefix(collection_id, u32::MAX, None);1349 let _ = <ReFungibleTransferBasket<T>>::clear_prefix((collection_id,), u32::MAX, None);13501351 let _ = <NftApproveBasket<T>>::clear_prefix(collection_id, u32::MAX, None);1352 let _ = <FungibleApproveBasket<T>>::clear_prefix(collection_id, u32::MAX, None);1353 let _ = <RefungibleApproveBasket<T>>::clear_prefix((collection_id,), u32::MAX, None);13541355 Ok(())1356 }13571358 fn structure_nesting_budget() -> budget::Value {1359 budget::Value::new(Self::nesting_budget())1360 }13611362 fn nesting_budget_weight(value: &budget::Value) -> Weight {1363 T::StructureWeightInfo::find_parent().saturating_mul(value.remaining() as u64)1364 }13651366 fn nesting_budget_predispatch_weight() -> Weight {1367 Self::nesting_budget_weight(&Self::structure_nesting_budget())1368 }13691370 pub fn dispatch_tx_with_nesting_budget<1371 C: FnOnce(&dyn CommonCollectionOperations<T>) -> DispatchResultWithPostInfo,1372 >(1373 collection: CollectionId,1374 budget: &budget::Value,1375 call: C,1376 ) -> DispatchResultWithPostInfo {1377 let mut result = dispatch_tx::<T, _>(collection, call);13781379 match &mut result {1380 Ok(PostDispatchInfo {1381 actual_weight: Some(weight),1382 ..1383 })1384 | Err(DispatchErrorWithPostInfo {1385 post_info: PostDispatchInfo {1386 actual_weight: Some(weight),1387 ..1388 },1389 ..1390 }) => *weight += Self::nesting_budget_weight(budget),1391 _ => {}1392 }13931394 result1395 }1396 }1397}primitives/data-structs/src/budget.rsdiffbeforeafterboth--- a/primitives/data-structs/src/budget.rs
+++ b/primitives/data-structs/src/budget.rs
@@ -22,7 +22,7 @@
pub fn new(v: u32) -> Self {
Self(Cell::new(v))
}
- pub fn remaining(&self) -> u32 {
+ pub fn refund_amount(self) -> u32 {
self.0.get()
}
}