difftreelog
fix clear VariableMetaDataBasket
in: master
1 file 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#![recursion_limit = "1024"]18#![cfg_attr(not(feature = "std"), no_std)]19#![allow(20 clippy::too_many_arguments,21 clippy::unnecessary_mut_passed,22 clippy::unused_unit23)]2425use frame_support::{26 decl_module, decl_storage, decl_error, decl_event,27 dispatch::DispatchResult,28 ensure,29 weights::{Weight},30 transactional,31 pallet_prelude::{DispatchResultWithPostInfo, ConstU32},32 BoundedVec,33};34use scale_info::TypeInfo;35use frame_system::{self as system, ensure_signed};36use sp_runtime::{sp_std::prelude::Vec};37use up_data_structs::{38 CONST_ON_CHAIN_SCHEMA_LIMIT, OFFCHAIN_SCHEMA_LIMIT,39 MAX_COLLECTION_NAME_LENGTH, MAX_COLLECTION_DESCRIPTION_LENGTH, MAX_TOKEN_PREFIX_LENGTH,40 AccessMode, CreateItemData, CollectionLimits, CollectionId, CollectionMode, TokenId,41 SchemaVersion, SponsorshipState, CreateCollectionData,42 CreateItemExData, budget, CollectionField, Property, PropertyKey, PropertyKeyPermission,43};44use pallet_evm::account::CrossAccountId;45use pallet_common::{46 CollectionHandle, Pallet as PalletCommon, CommonWeightInfo,47 dispatch::dispatch_call, dispatch::CollectionDispatch,48};4950#[cfg(feature = "runtime-benchmarks")]51mod benchmarking;52pub mod weights;53use weights::WeightInfo;5455decl_error! {56 /// Error for non-fungible-token module.57 pub enum Error for Module<T: Config> {58 /// Decimal_points parameter must be lower than MAX_DECIMAL_POINTS constant, currently it is 30.59 CollectionDecimalPointLimitExceeded,60 /// This address is not set as sponsor, use setCollectionSponsor first.61 ConfirmUnsetSponsorFail,62 /// Length of items properties must be greater than 0.63 EmptyArgument,64 }65}6667pub trait Config: system::Config + pallet_common::Config + Sized + TypeInfo {68 type Event: From<Event<Self>> + Into<<Self as frame_system::Config>::Event>;6970 /// Weight information for extrinsics in this pallet.71 type WeightInfo: WeightInfo;72 type CommonWeightInfo: CommonWeightInfo<Self::CrossAccountId>;73}7475decl_event! {76 pub enum Event<T>77 where78 <T as frame_system::Config>::AccountId,79 <T as pallet_evm::account::Config>::CrossAccountId,80 {81 /// Collection sponsor was removed82 ///83 /// # Arguments84 ///85 /// * collection_id: Globally unique collection identifier.86 CollectionSponsorRemoved(CollectionId),8788 /// Collection admin was added89 ///90 /// # Arguments91 ///92 /// * collection_id: Globally unique collection identifier.93 ///94 /// * admin: Admin address.95 CollectionAdminAdded(CollectionId, CrossAccountId),9697 /// Collection owned was change98 ///99 /// # Arguments100 ///101 /// * collection_id: Globally unique collection identifier.102 ///103 /// * owner: New owner address.104 CollectionOwnedChanged(CollectionId, AccountId),105106 /// Collection sponsor was set107 ///108 /// # Arguments109 ///110 /// * collection_id: Globally unique collection identifier.111 ///112 /// * owner: New sponsor address.113 CollectionSponsorSet(CollectionId, AccountId),114115 /// const on chain schema was set116 ///117 /// # Arguments118 ///119 /// * collection_id: Globally unique collection identifier.120 ConstOnChainSchemaSet(CollectionId),121122 /// New sponsor was confirm123 ///124 /// # Arguments125 ///126 /// * collection_id: Globally unique collection identifier.127 ///128 /// * sponsor: New sponsor address.129 SponsorshipConfirmed(CollectionId, AccountId),130131 /// Collection admin was removed132 ///133 /// # Arguments134 ///135 /// * collection_id: Globally unique collection identifier.136 ///137 /// * admin: Admin address.138 CollectionAdminRemoved(CollectionId, CrossAccountId),139140 /// Address was remove from allow list141 ///142 /// # Arguments143 ///144 /// * collection_id: Globally unique collection identifier.145 ///146 /// * user: Address.147 AllowListAddressRemoved(CollectionId, CrossAccountId),148149 /// Address was add to allow list150 ///151 /// # Arguments152 ///153 /// * collection_id: Globally unique collection identifier.154 ///155 /// * user: Address.156 AllowListAddressAdded(CollectionId, CrossAccountId),157158 /// Collection limits was set159 ///160 /// # Arguments161 ///162 /// * collection_id: Globally unique collection identifier.163 CollectionLimitSet(CollectionId),164165 /// Mint permission was set166 ///167 /// # Arguments168 ///169 /// * collection_id: Globally unique collection identifier.170 MintPermissionSet(CollectionId),171172 /// Offchain schema was set173 ///174 /// # Arguments175 ///176 /// * collection_id: Globally unique collection identifier.177 OffchainSchemaSet(CollectionId),178179 /// Public access mode was set180 ///181 /// # Arguments182 ///183 /// * collection_id: Globally unique collection identifier.184 ///185 /// * mode: New access state.186 PublicAccessModeSet(CollectionId, AccessMode),187188 /// Schema version was set189 ///190 /// # Arguments191 ///192 /// * collection_id: Globally unique collection identifier.193 SchemaVersionSet(CollectionId),194 }195}196197type SelfWeightOf<T> = <T as Config>::WeightInfo;198199// # Used definitions200//201// ## User control levels202//203// chain-controlled - key is uncontrolled by user204// i.e autoincrementing index205// can use non-cryptographic hash206// real - key is controlled by user207// but it is hard to generate enough colliding values, i.e owner of signed txs208// can use non-cryptographic hash209// controlled - key is completly controlled by users210// i.e maps with mutable keys211// should use cryptographic hash212//213// ## User control level downgrade reasons214//215// ?1 - chain-controlled -> controlled216// collections/tokens can be destroyed, resulting in massive holes217// ?2 - chain-controlled -> controlled218// same as ?1, but can be only added, resulting in easier exploitation219// ?3 - real -> controlled220// no confirmation required, so addresses can be easily generated221decl_storage! {222 trait Store for Module<T: Config> as Unique {223224 //#region Private members225 /// Used for migrations226 ChainVersion: u64;227 //#endregion228229 //#region Tokens transfer rate limit baskets230 /// (Collection id (controlled?2), who created (real))231 /// TODO: Off chain worker should remove from this map when collection gets removed232 pub CreateItemBasket get(fn create_item_basket): map hasher(blake2_128_concat) (CollectionId, T::AccountId) => Option<T::BlockNumber>;233 /// Collection id (controlled?2), token id (controlled?2)234 pub NftTransferBasket get(fn nft_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<T::BlockNumber>;235 /// Collection id (controlled?2), owning user (real)236 pub FungibleTransferBasket get(fn fungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => Option<T::BlockNumber>;237 /// Collection id (controlled?2), token id (controlled?2)238 pub ReFungibleTransferBasket get(fn refungible_transfer_basket): nmap hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId, hasher(twox_64_concat) T::AccountId => Option<T::BlockNumber>;239 //#endregion240241 /// Approval sponsoring242 pub NftApproveBasket get(fn nft_approve_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<T::BlockNumber>;243 pub FungibleApproveBasket get(fn fungible_approve_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => Option<T::BlockNumber>;244 pub RefungibleApproveBasket get(fn refungible_approve_basket): nmap hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId, hasher(twox_64_concat) T::AccountId => Option<T::BlockNumber>;245 }246}247248decl_module! {249 pub struct Module<T: Config> for enum Call250 where251 origin: T::Origin252 {253 type Error = Error<T>;254255 fn deposit_event() = default;256257 fn on_initialize(_now: T::BlockNumber) -> Weight {258 0259 }260261 /// This method creates a Collection of NFTs. Each Token may have multiple properties encoded as an array of bytes of certain length. The initial owner of the collection is set to the address that signed the transaction and can be changed later.262 ///263 /// # Permissions264 ///265 /// * Anyone.266 ///267 /// # Arguments268 ///269 /// * collection_name: UTF-16 string with collection name (limit 64 characters), will be stored as zero-terminated.270 ///271 /// * collection_description: UTF-16 string with collection description (limit 256 characters), will be stored as zero-terminated.272 ///273 /// * token_prefix: UTF-8 string with token prefix.274 ///275 /// * mode: [CollectionMode] collection type and type dependent data.276 // returns collection ID277 #[weight = <SelfWeightOf<T>>::create_collection()]278 #[transactional]279 #[deprecated]280 pub fn create_collection(origin,281 collection_name: BoundedVec<u16, ConstU32<MAX_COLLECTION_NAME_LENGTH>>,282 collection_description: BoundedVec<u16, ConstU32<MAX_COLLECTION_DESCRIPTION_LENGTH>>,283 token_prefix: BoundedVec<u8, ConstU32<MAX_TOKEN_PREFIX_LENGTH>>,284 mode: CollectionMode) -> DispatchResult {285 let data: CreateCollectionData<T::AccountId> = CreateCollectionData {286 name: collection_name,287 description: collection_description,288 token_prefix,289 mode,290 ..Default::default()291 };292 Self::create_collection_ex(origin, data)293 }294295 /// This method creates a collection296 ///297 /// Prefer it to deprecated [`created_collection`] method298 #[weight = <SelfWeightOf<T>>::create_collection()]299 #[transactional]300 pub fn create_collection_ex(origin, data: CreateCollectionData<T::AccountId>) -> DispatchResult {301 let sender = ensure_signed(origin)?;302303 // =========304305 T::CollectionDispatch::create(sender, data)?;306307 Ok(())308 }309310 /// **DANGEROUS**: Destroys collection and all NFTs within this collection. Users irrecoverably lose their assets and may lose real money.311 ///312 /// # Permissions313 ///314 /// * Collection Owner.315 ///316 /// # Arguments317 ///318 /// * collection_id: collection to destroy.319 #[weight = <SelfWeightOf<T>>::destroy_collection()]320 #[transactional]321 pub fn destroy_collection(origin, collection_id: CollectionId) -> DispatchResult {322 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);323 let collection = <CollectionHandle<T>>::try_get(collection_id)?;324325 // =========326327 T::CollectionDispatch::destroy(sender, collection)?;328329 <NftTransferBasket<T>>::remove_prefix(collection_id, None);330 <FungibleTransferBasket<T>>::remove_prefix(collection_id, None);331 <ReFungibleTransferBasket<T>>::remove_prefix((collection_id,), None);332333 <NftApproveBasket<T>>::remove_prefix(collection_id, None);334 <FungibleApproveBasket<T>>::remove_prefix(collection_id, None);335 <RefungibleApproveBasket<T>>::remove_prefix((collection_id,), None);336337 Ok(())338 }339340 /// Add an address to allow list.341 ///342 /// # Permissions343 ///344 /// * Collection Owner345 /// * Collection Admin346 ///347 /// # Arguments348 ///349 /// * collection_id.350 ///351 /// * address.352 #[weight = <SelfWeightOf<T>>::add_to_allow_list()]353 #[transactional]354 pub fn add_to_allow_list(origin, collection_id: CollectionId, address: T::CrossAccountId) -> DispatchResult{355356 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);357 let collection = <CollectionHandle<T>>::try_get(collection_id)?;358359 <PalletCommon<T>>::toggle_allowlist(360 &collection,361 &sender,362 &address,363 true,364 )?;365366 Self::deposit_event(Event::<T>::AllowListAddressAdded(367 collection_id,368 address369 ));370371 Ok(())372 }373374 /// Remove an address from allow list.375 ///376 /// # Permissions377 ///378 /// * Collection Owner379 /// * Collection Admin380 ///381 /// # Arguments382 ///383 /// * collection_id.384 ///385 /// * address.386 #[weight = <SelfWeightOf<T>>::remove_from_allow_list()]387 #[transactional]388 pub fn remove_from_allow_list(origin, collection_id: CollectionId, address: T::CrossAccountId) -> DispatchResult{389390 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);391 let collection = <CollectionHandle<T>>::try_get(collection_id)?;392393 <PalletCommon<T>>::toggle_allowlist(394 &collection,395 &sender,396 &address,397 false,398 )?;399400 <Pallet<T>>::deposit_event(Event::<T>::AllowListAddressRemoved(401 collection_id,402 address403 ));404405 Ok(())406 }407408 /// Toggle between normal and allow list access for the methods with access for `Anyone`.409 ///410 /// # Permissions411 ///412 /// * Collection Owner.413 ///414 /// # Arguments415 ///416 /// * collection_id.417 ///418 /// * mode: [AccessMode]419 #[weight = <SelfWeightOf<T>>::set_public_access_mode()]420 #[transactional]421 pub fn set_public_access_mode(origin, collection_id: CollectionId, mode: AccessMode) -> DispatchResult422 {423 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);424425 let mut target_collection = <CollectionHandle<T>>::try_get(collection_id)?;426 target_collection.check_is_owner(&sender)?;427428 target_collection.access = mode.clone();429430 <Pallet<T>>::deposit_event(Event::<T>::PublicAccessModeSet(431 collection_id,432 mode433 ));434435 target_collection.save()436 }437438 /// Allows Anyone to create tokens if:439 /// * Allow List is enabled, and440 /// * Address is added to allow list, and441 /// * This method was called with True parameter442 ///443 /// # Permissions444 /// * Collection Owner445 ///446 /// # Arguments447 ///448 /// * collection_id.449 ///450 /// * mint_permission: Boolean parameter. If True, allows minting to Anyone with conditions above.451 #[weight = <SelfWeightOf<T>>::set_mint_permission()]452 #[transactional]453 pub fn set_mint_permission(origin, collection_id: CollectionId, mint_permission: bool) -> DispatchResult454 {455 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);456457 let mut target_collection = <CollectionHandle<T>>::try_get(collection_id)?;458 target_collection.check_is_owner(&sender)?;459460 target_collection.mint_mode = mint_permission;461462 <Pallet<T>>::deposit_event(Event::<T>::MintPermissionSet(463 collection_id464 ));465466 target_collection.save()467 }468469 /// Change the owner of the collection.470 ///471 /// # Permissions472 ///473 /// * Collection Owner.474 ///475 /// # Arguments476 ///477 /// * collection_id.478 ///479 /// * new_owner.480 #[weight = <SelfWeightOf<T>>::change_collection_owner()]481 #[transactional]482 pub fn change_collection_owner(origin, collection_id: CollectionId, new_owner: T::AccountId) -> DispatchResult {483484 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);485486 let mut target_collection = <CollectionHandle<T>>::try_get(collection_id)?;487 target_collection.check_is_owner(&sender)?;488489 target_collection.owner = new_owner.clone();490 <Pallet<T>>::deposit_event(Event::<T>::CollectionOwnedChanged(491 collection_id,492 new_owner493 ));494495 target_collection.save()496 }497498 /// Adds an admin of the Collection.499 /// NFT Collection can be controlled by multiple admin addresses (some which can also be servers, for example). Admins can issue and burn NFTs, as well as add and remove other admins, but cannot change NFT or Collection ownership.500 ///501 /// # Permissions502 ///503 /// * Collection Owner.504 /// * Collection Admin.505 ///506 /// # Arguments507 ///508 /// * collection_id: ID of the Collection to add admin for.509 ///510 /// * new_admin_id: Address of new admin to add.511 #[weight = <SelfWeightOf<T>>::add_collection_admin()]512 #[transactional]513 pub fn add_collection_admin(origin, collection_id: CollectionId, new_admin_id: T::CrossAccountId) -> DispatchResult {514 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);515 let collection = <CollectionHandle<T>>::try_get(collection_id)?;516517 <Pallet<T>>::deposit_event(Event::<T>::CollectionAdminAdded(518 collection_id,519 new_admin_id.clone()520 ));521522 <PalletCommon<T>>::toggle_admin(&collection, &sender, &new_admin_id, true)523 }524525 /// Remove admin address of the Collection. An admin address can remove itself. List of admins may become empty, in which case only Collection Owner will be able to add an Admin.526 ///527 /// # Permissions528 ///529 /// * Collection Owner.530 /// * Collection Admin.531 ///532 /// # Arguments533 ///534 /// * collection_id: ID of the Collection to remove admin for.535 ///536 /// * account_id: Address of admin to remove.537 #[weight = <SelfWeightOf<T>>::remove_collection_admin()]538 #[transactional]539 pub fn remove_collection_admin(origin, collection_id: CollectionId, account_id: T::CrossAccountId) -> DispatchResult {540 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);541 let collection = <CollectionHandle<T>>::try_get(collection_id)?;542543 <Pallet<T>>::deposit_event(Event::<T>::CollectionAdminRemoved(544 collection_id,545 account_id.clone()546 ));547548 <PalletCommon<T>>::toggle_admin(&collection, &sender, &account_id, false)549 }550551 /// # Permissions552 ///553 /// * Collection Owner554 ///555 /// # Arguments556 ///557 /// * collection_id.558 ///559 /// * new_sponsor.560 #[weight = <SelfWeightOf<T>>::set_collection_sponsor()]561 #[transactional]562 pub fn set_collection_sponsor(origin, collection_id: CollectionId, new_sponsor: T::AccountId) -> DispatchResult {563 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);564565 let mut target_collection = <CollectionHandle<T>>::try_get(collection_id)?;566 target_collection.check_is_owner(&sender)?;567568 target_collection.sponsorship = SponsorshipState::Unconfirmed(new_sponsor.clone());569570 <Pallet<T>>::deposit_event(Event::<T>::CollectionSponsorSet(571 collection_id,572 new_sponsor573 ));574575 target_collection.save()576 }577578 /// # Permissions579 ///580 /// * Sponsor.581 ///582 /// # Arguments583 ///584 /// * collection_id.585 #[weight = <SelfWeightOf<T>>::confirm_sponsorship()]586 #[transactional]587 pub fn confirm_sponsorship(origin, collection_id: CollectionId) -> DispatchResult {588 let sender = ensure_signed(origin)?;589590 let mut target_collection = <CollectionHandle<T>>::try_get(collection_id)?;591 ensure!(592 target_collection.sponsorship.pending_sponsor() == Some(&sender),593 Error::<T>::ConfirmUnsetSponsorFail594 );595596 target_collection.sponsorship = SponsorshipState::Confirmed(sender.clone());597598 <Pallet<T>>::deposit_event(Event::<T>::SponsorshipConfirmed(599 collection_id,600 sender601 ));602603 target_collection.save()604 }605606 /// Switch back to pay-per-own-transaction model.607 ///608 /// # Permissions609 ///610 /// * Collection owner.611 ///612 /// # Arguments613 ///614 /// * collection_id.615 #[weight = <SelfWeightOf<T>>::remove_collection_sponsor()]616 #[transactional]617 pub fn remove_collection_sponsor(origin, collection_id: CollectionId) -> DispatchResult {618 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);619620 let mut target_collection = <CollectionHandle<T>>::try_get(collection_id)?;621 target_collection.check_is_owner(&sender)?;622623 target_collection.sponsorship = SponsorshipState::Disabled;624625 <Pallet<T>>::deposit_event(Event::<T>::CollectionSponsorRemoved(626 collection_id627 ));628 target_collection.save()629 }630631 /// This method creates a concrete instance of NFT Collection created with CreateCollection method.632 ///633 /// # Permissions634 ///635 /// * Collection Owner.636 /// * Collection Admin.637 /// * Anyone if638 /// * Allow List is enabled, and639 /// * Address is added to allow list, and640 /// * MintPermission is enabled (see SetMintPermission method)641 ///642 /// # Arguments643 ///644 /// * collection_id: ID of the collection.645 ///646 /// * owner: Address, initial owner of the NFT.647 ///648 /// * data: Token data to store on chain.649 #[weight = T::CommonWeightInfo::create_item()]650 #[transactional]651 pub fn create_item(origin, collection_id: CollectionId, owner: T::CrossAccountId, data: CreateItemData) -> DispatchResultWithPostInfo {652 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);653 let budget = budget::Value::new(2);654655 dispatch_call::<T, _>(collection_id, |d| d.create_item(sender, owner, data, &budget))656 }657658 /// This method creates multiple items in a collection created with CreateCollection method.659 ///660 /// # Permissions661 ///662 /// * Collection Owner.663 /// * Collection Admin.664 /// * Anyone if665 /// * Allow List is enabled, and666 /// * Address is added to allow list, and667 /// * MintPermission is enabled (see SetMintPermission method)668 ///669 /// # Arguments670 ///671 /// * collection_id: ID of the collection.672 ///673 /// * itemsData: Array items properties. Each property is an array of bytes itself, see [create_item].674 ///675 /// * owner: Address, initial owner of the NFT.676 #[weight = T::CommonWeightInfo::create_multiple_items(items_data.len() as u32)]677 #[transactional]678 pub fn create_multiple_items(origin, collection_id: CollectionId, owner: T::CrossAccountId, items_data: Vec<CreateItemData>) -> DispatchResultWithPostInfo {679 ensure!(!items_data.is_empty(), Error::<T>::EmptyArgument);680 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);681 let budget = budget::Value::new(2);682683 dispatch_call::<T, _>(collection_id, |d| d.create_multiple_items(sender, owner, items_data, &budget))684 }685686 #[weight = T::CommonWeightInfo::set_collection_properties(properties.len() as u32)]687 #[transactional]688 pub fn set_collection_properties(689 origin,690 collection_id: CollectionId,691 properties: Vec<Property>692 ) -> DispatchResultWithPostInfo {693 ensure!(!properties.is_empty(), Error::<T>::EmptyArgument);694695 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);696697 dispatch_call::<T, _>(collection_id, |d| d.set_collection_properties(sender, properties))698 }699700 #[weight = T::CommonWeightInfo::delete_collection_properties(property_keys.len() as u32)]701 #[transactional]702 pub fn delete_collection_properties(703 origin,704 collection_id: CollectionId,705 property_keys: Vec<PropertyKey>,706 ) -> DispatchResultWithPostInfo {707 ensure!(!property_keys.is_empty(), Error::<T>::EmptyArgument);708709 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);710711 dispatch_call::<T, _>(collection_id, |d| d.delete_collection_properties(&sender, property_keys))712 }713714 #[weight = T::CommonWeightInfo::set_token_properties(properties.len() as u32)]715 #[transactional]716 pub fn set_token_properties(717 origin,718 collection_id: CollectionId,719 token_id: TokenId,720 properties: Vec<Property>721 ) -> DispatchResultWithPostInfo {722 ensure!(!properties.is_empty(), Error::<T>::EmptyArgument);723724 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);725726 dispatch_call::<T, _>(collection_id, |d| d.set_token_properties(sender, token_id, properties))727 }728729 #[weight = T::CommonWeightInfo::delete_token_properties(property_keys.len() as u32)]730 #[transactional]731 pub fn delete_token_properties(732 origin,733 collection_id: CollectionId,734 token_id: TokenId,735 property_keys: Vec<PropertyKey>736 ) -> DispatchResultWithPostInfo {737 ensure!(!property_keys.is_empty(), Error::<T>::EmptyArgument);738739 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);740741 dispatch_call::<T, _>(collection_id, |d| d.delete_token_properties(sender, token_id, property_keys))742 }743744 #[weight = T::CommonWeightInfo::set_property_permissions(property_permissions.len() as u32)]745 #[transactional]746 pub fn set_property_permissions(747 origin,748 collection_id: CollectionId,749 property_permissions: Vec<PropertyKeyPermission>,750 ) -> DispatchResultWithPostInfo {751 ensure!(!property_permissions.is_empty(), Error::<T>::EmptyArgument);752753 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);754755 dispatch_call::<T, _>(collection_id, |d| d.set_property_permissions(&sender, property_permissions))756 }757758 #[weight = T::CommonWeightInfo::create_multiple_items_ex(&data)]759 #[transactional]760 pub fn create_multiple_items_ex(origin, collection_id: CollectionId, data: CreateItemExData<T::CrossAccountId>) -> DispatchResultWithPostInfo {761 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);762 let budget = budget::Value::new(2);763764 dispatch_call::<T, _>(collection_id, |d| d.create_multiple_items_ex(sender, data, &budget))765 }766767 // TODO! transaction weight768769 /// Set transfers_enabled value for particular collection770 ///771 /// # Permissions772 ///773 /// * Collection Owner.774 ///775 /// # Arguments776 ///777 /// * collection_id: ID of the collection.778 ///779 /// * value: New flag value.780 #[weight = <SelfWeightOf<T>>::set_transfers_enabled_flag()]781 #[transactional]782 pub fn set_transfers_enabled_flag(origin, collection_id: CollectionId, value: bool) -> DispatchResult {783 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);784 let mut target_collection = <CollectionHandle<T>>::try_get(collection_id)?;785 target_collection.check_is_owner(&sender)?;786787 // =========788789 target_collection.limits.transfers_enabled = Some(value);790 target_collection.save()791 }792793 /// Destroys a concrete instance of NFT.794 ///795 /// # Permissions796 ///797 /// * Collection Owner.798 /// * Collection Admin.799 /// * Current NFT Owner.800 ///801 /// # Arguments802 ///803 /// * collection_id: ID of the collection.804 ///805 /// * item_id: ID of NFT to burn.806 #[weight = T::CommonWeightInfo::burn_item()]807 #[transactional]808 pub fn burn_item(origin, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResultWithPostInfo {809 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);810811 let post_info = dispatch_call::<T, _>(collection_id, |d| d.burn_item(sender, item_id, value))?;812 if value == 1 {813 <NftTransferBasket<T>>::remove(collection_id, item_id);814 <NftApproveBasket<T>>::remove(collection_id, item_id);815 }816 // Those maps should be cleared only if token disappears completly, need to move this part of logic to pallets?817 // <FungibleApproveBasket<T>>::remove(collection_id, sender.as_sub());818 // <RefungibleApproveBasket<T>>::remove((collection_id, item_id, sender.as_sub()));819 Ok(post_info)820 }821822 /// Destroys a concrete instance of NFT on behalf of the owner823 /// See also: [`approve`]824 ///825 /// # Permissions826 ///827 /// * Collection Owner.828 /// * Collection Admin.829 /// * Current NFT Owner.830 ///831 /// # Arguments832 ///833 /// * collection_id: ID of the collection.834 ///835 /// * item_id: ID of NFT to burn.836 ///837 /// * from: owner of item838 #[weight = T::CommonWeightInfo::burn_from()]839 #[transactional]840 pub fn burn_from(origin, collection_id: CollectionId, from: T::CrossAccountId, item_id: TokenId, value: u128) -> DispatchResultWithPostInfo {841 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);842 let budget = budget::Value::new(2);843844 dispatch_call::<T, _>(collection_id, |d| d.burn_from(sender, from, item_id, value, &budget))845 }846847 /// Change ownership of the token.848 ///849 /// # Permissions850 ///851 /// * Collection Owner852 /// * Collection Admin853 /// * Current NFT owner854 ///855 /// # Arguments856 ///857 /// * recipient: Address of token recipient.858 ///859 /// * collection_id.860 ///861 /// * item_id: ID of the item862 /// * Non-Fungible Mode: Required.863 /// * Fungible Mode: Ignored.864 /// * Re-Fungible Mode: Required.865 ///866 /// * value: Amount to transfer.867 /// * Non-Fungible Mode: Ignored868 /// * Fungible Mode: Must specify transferred amount869 /// * Re-Fungible Mode: Must specify transferred portion (between 0 and 1)870 #[weight = T::CommonWeightInfo::transfer()]871 #[transactional]872 pub fn transfer(origin, recipient: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResultWithPostInfo {873 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);874 let budget = budget::Value::new(2);875876 dispatch_call::<T, _>(collection_id, |d| d.transfer(sender, recipient, item_id, value, &budget))877 }878879 /// Set, change, or remove approved address to transfer the ownership of the NFT.880 ///881 /// # Permissions882 ///883 /// * Collection Owner884 /// * Collection Admin885 /// * Current NFT owner886 ///887 /// # Arguments888 ///889 /// * approved: Address that is approved to transfer this NFT or zero (if needed to remove approval).890 ///891 /// * collection_id.892 ///893 /// * item_id: ID of the item.894 #[weight = T::CommonWeightInfo::approve()]895 #[transactional]896 pub fn approve(origin, spender: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, amount: u128) -> DispatchResultWithPostInfo {897 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);898899 dispatch_call::<T, _>(collection_id, |d| d.approve(sender, spender, item_id, amount))900 }901902 /// Change ownership of a NFT on behalf of the owner. See Approve method for additional information. After this method executes, the approval is removed so that the approved address will not be able to transfer this NFT again from this owner.903 ///904 /// # Permissions905 /// * Collection Owner906 /// * Collection Admin907 /// * Current NFT owner908 /// * Address approved by current NFT owner909 ///910 /// # Arguments911 ///912 /// * from: Address that owns token.913 ///914 /// * recipient: Address of token recipient.915 ///916 /// * collection_id.917 ///918 /// * item_id: ID of the item.919 ///920 /// * value: Amount to transfer.921 #[weight = T::CommonWeightInfo::transfer_from()]922 #[transactional]923 pub fn transfer_from(origin, from: T::CrossAccountId, recipient: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, value: u128 ) -> DispatchResultWithPostInfo {924 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);925 let budget = budget::Value::new(2);926927 dispatch_call::<T, _>(collection_id, |d| d.transfer_from(sender, from, recipient, item_id, value, &budget))928 }929930 /// Set schema standard931 /// ImageURL932 /// Unique933 ///934 /// # Permissions935 ///936 /// * Collection Owner937 /// * Collection Admin938 ///939 /// # Arguments940 ///941 /// * collection_id.942 ///943 /// * schema: SchemaVersion: enum944 #[weight = <SelfWeightOf<T>>::set_schema_version()]945 #[transactional]946 pub fn set_schema_version(947 origin,948 collection_id: CollectionId,949 version: SchemaVersion950 ) -> DispatchResult {951 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);952 let mut target_collection = <CollectionHandle<T>>::try_get(collection_id)?;953 target_collection.check_is_owner_or_admin(&sender)?;954 target_collection.schema_version = version;955956 <Pallet<T>>::deposit_event(Event::<T>::SchemaVersionSet(957 collection_id958 ));959960 target_collection.save()961 }962963 /// Set off-chain data schema.964 ///965 /// # Permissions966 ///967 /// * Collection Owner968 /// * Collection Admin969 ///970 /// # Arguments971 ///972 /// * collection_id.973 ///974 /// * schema: String representing the offchain data schema.975 #[weight = <SelfWeightOf<T>>::set_offchain_schema(schema.len() as u32)]976 #[transactional]977 pub fn set_offchain_schema(978 origin,979 collection_id: CollectionId,980 schema: BoundedVec<u8, ConstU32<OFFCHAIN_SCHEMA_LIMIT>>,981 ) -> DispatchResult {982 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);983 let collection = <CollectionHandle<T>>::try_get(collection_id)?;984985 // =========986987 <PalletCommon<T>>::set_field(&collection, &sender, CollectionField::OffchainSchema, schema.into_inner())?;988989 <Pallet<T>>::deposit_event(Event::<T>::OffchainSchemaSet(990 collection_id991 ));992 Ok(())993 }994995 /// Set const on-chain data schema.996 ///997 /// # Permissions998 ///999 /// * Collection Owner1000 /// * Collection Admin1001 ///1002 /// # Arguments1003 ///1004 /// * collection_id.1005 ///1006 /// * schema: String representing the const on-chain data schema.1007 #[weight = <SelfWeightOf<T>>::set_const_on_chain_schema(schema.len() as u32)]1008 #[transactional]1009 pub fn set_const_on_chain_schema (1010 origin,1011 collection_id: CollectionId,1012 schema: BoundedVec<u8, ConstU32<CONST_ON_CHAIN_SCHEMA_LIMIT>>1013 ) -> DispatchResult {1014 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1015 let collection = <CollectionHandle<T>>::try_get(collection_id)?;10161017 // =========10181019 <PalletCommon<T>>::set_field(&collection, &sender, CollectionField::ConstOnChainSchema, schema.into_inner())?;10201021 <Pallet<T>>::deposit_event(Event::<T>::ConstOnChainSchemaSet(1022 collection_id1023 ));1024 Ok(())1025 }10261027 #[weight = <SelfWeightOf<T>>::set_collection_limits()]1028 #[transactional]1029 pub fn set_collection_limits(1030 origin,1031 collection_id: CollectionId,1032 new_limit: CollectionLimits,1033 ) -> DispatchResult {1034 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1035 let mut target_collection = <CollectionHandle<T>>::try_get(collection_id)?;1036 target_collection.check_is_owner(&sender)?;1037 let old_limit = &target_collection.limits;10381039 target_collection.limits = <PalletCommon<T>>::clamp_limits(target_collection.mode.clone(), &old_limit, new_limit)?;10401041 <Pallet<T>>::deposit_event(Event::<T>::CollectionLimitSet(1042 collection_id1043 ));10441045 target_collection.save()1046 }1047 }1048}