git.delta.rocks / unique-network / refs/commits / 8bbc7539fcb3

1// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.2// This file is part of Unique Network.34// Unique Network is free software: you can redistribute it and/or modify5// it under the terms of the GNU General Public License as published by6// the Free Software Foundation, either version 3 of the License, or7// (at your option) any later version.89// Unique Network is distributed in the hope that it will be useful,10// but WITHOUT ANY WARRANTY; without even the implied warranty of11// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the12// GNU General Public License for more details.1314// You should have received a copy of the GNU General Public License15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.1617#![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)]2425extern crate alloc;2627pub use serde::{Serialize, Deserialize};2829pub use frame_support::{30	construct_runtime, decl_module, decl_storage, decl_error, decl_event,31	dispatch::DispatchResult,32	ensure, fail, parameter_types,33	traits::{34		ExistenceRequirement, Get, Imbalance, KeyOwnerProofSystem, OnUnbalanced, Randomness,35		IsSubType, WithdrawReasons,36	},37	weights::{38		constants::{BlockExecutionWeight, ExtrinsicBaseWeight, RocksDbWeight, WEIGHT_PER_SECOND},39		DispatchInfo, GetDispatchInfo, IdentityFee, Pays, PostDispatchInfo, Weight,40		WeightToFeePolynomial, DispatchClass,41	},42	StorageValue, transactional,43	pallet_prelude::{DispatchResultWithPostInfo, ConstU32},44	BoundedVec,45};46use scale_info::TypeInfo;47use frame_system::{self as system, ensure_signed};48use sp_runtime::{sp_std::prelude::Vec};49use up_data_structs::{50	MAX_DECIMAL_POINTS, VARIABLE_ON_CHAIN_SCHEMA_LIMIT, CONST_ON_CHAIN_SCHEMA_LIMIT,51	OFFCHAIN_SCHEMA_LIMIT, MAX_COLLECTION_NAME_LENGTH, MAX_COLLECTION_DESCRIPTION_LENGTH,52	MAX_TOKEN_PREFIX_LENGTH, AccessMode, CreateItemData, CollectionLimits, CollectionId,53	CollectionMode, TokenId, SchemaVersion, SponsorshipState, MetaUpdatePermission,54	CreateCollectionData, CustomDataLimit, CreateItemExData,55};56use pallet_common::{57	account::CrossAccountId, CollectionHandle, Pallet as PalletCommon, Error as CommonError,58	CommonWeightInfo,59};60use pallet_refungible::{Pallet as PalletRefungible, RefungibleHandle};61use pallet_fungible::{Pallet as PalletFungible, FungibleHandle};62use pallet_nonfungible::{Pallet as PalletNonfungible, NonfungibleHandle};6364#[cfg(test)]65mod mock;6667#[cfg(test)]68mod tests;6970mod eth;71mod sponsorship;72pub use sponsorship::{UniqueSponsorshipHandler, UniqueSponsorshipPredict};73pub use eth::sponsoring::UniqueEthSponsorshipHandler;7475pub use eth::UniqueErcSupport;7677pub mod common;78use common::CommonWeights;79pub mod dispatch;80use dispatch::dispatch_call;8182#[cfg(feature = "runtime-benchmarks")]83mod benchmarking;84pub mod weights;85use weights::WeightInfo;8687pub trait SponsorshipPredict<T: Config> {88	fn predict(collection: CollectionId, account: T::CrossAccountId, token: TokenId) -> Option<u64>89	where90		u64: From<<T as frame_system::Config>::BlockNumber>;91}9293decl_error! {94	/// Error for non-fungible-token module.95	pub enum Error for Module<T: Config> {96		/// Decimal_points parameter must be lower than MAX_DECIMAL_POINTS constant, currently it is 30.97		CollectionDecimalPointLimitExceeded,98		/// This address is not set as sponsor, use setCollectionSponsor first.99		ConfirmUnsetSponsorFail,100		/// Length of items properties must be greater than 0.101		EmptyArgument,102	}103}104105pub trait Config:106	system::Config107	+ pallet_evm_coder_substrate::Config108	+ pallet_common::Config109	+ pallet_nonfungible::Config110	+ pallet_refungible::Config111	+ pallet_fungible::Config112	+ Sized113	+ TypeInfo114{115	type Event: From<Event<Self>> + Into<<Self as frame_system::Config>::Event>;116117	/// Weight information for extrinsics in this pallet.118	type WeightInfo: WeightInfo;119}120121decl_event! {122	pub enum Event<T>123	where124		<T as frame_system::Config>::AccountId,125		<T as pallet_common::Config>::CrossAccountId,126	{127		/// Collection sponsor was removed128		///129		/// # Arguments130		///131		/// * collection_id: Globally unique collection identifier.132		CollectionSponsorRemoved(CollectionId),133134		/// Collection admin was added135		///136		/// # Arguments137		///138		/// * collection_id: Globally unique collection identifier.139		///140		/// * admin:  Admin address.141		CollectionAdminAdded(CollectionId, CrossAccountId),142143		/// Collection owned was change144		///145		/// # Arguments146		///147		/// * collection_id: Globally unique collection identifier.148		///149		/// * owner:  New owner address.150		CollectionOwnedChanged(CollectionId, AccountId),151152		/// Collection sponsor was set153		///154		/// # Arguments155		///156		/// * collection_id: Globally unique collection identifier.157		///158		/// * owner:  New sponsor address.159		CollectionSponsorSet(CollectionId, AccountId),160161		/// const on chain schema was set162		///163		/// # Arguments164		///165		/// * collection_id: Globally unique collection identifier.166		ConstOnChainSchemaSet(CollectionId),167168		/// New sponsor was confirm169		///170		/// # Arguments171		///172		/// * collection_id: Globally unique collection identifier.173		///174		/// * sponsor:  New sponsor address.175		SponsorshipConfirmed(CollectionId, AccountId),176177		/// Collection admin was removed178		///179		/// # Arguments180		///181		/// * collection_id: Globally unique collection identifier.182		///183		/// * admin:  Admin address.184		CollectionAdminRemoved(CollectionId, CrossAccountId),185186		/// Address was remove from allow list187		///188		/// # Arguments189		///190		/// * collection_id: Globally unique collection identifier.191		///192		/// * user:  Address.193		AllowListAddressRemoved(CollectionId, CrossAccountId),194195		/// Address was add to allow list196		///197		/// # Arguments198		///199		/// * collection_id: Globally unique collection identifier.200		///201		/// * user:  Address.202		AllowListAddressAdded(CollectionId, CrossAccountId),203204		/// Collection limits was set205		///206		/// # Arguments207		///208		/// * collection_id: Globally unique collection identifier.209		CollectionLimitSet(CollectionId),210211		/// Mint permission	was set212		///213		/// # Arguments214		///215		/// * collection_id: Globally unique collection identifier.216		MintPermissionSet(CollectionId),217218		/// Offchain schema was set219		///220		/// # Arguments221		///222		/// * collection_id: Globally unique collection identifier.223		OffchainSchemaSet(CollectionId),224225		/// Public access mode was set226		///227		/// # Arguments228		///229		/// * collection_id: Globally unique collection identifier.230		///231		/// * mode: New access state.232		PublicAccessModeSet(CollectionId, AccessMode),233234		/// Schema version was set235		///236		/// # Arguments237		///238		/// * collection_id: Globally unique collection identifier.239		SchemaVersionSet(CollectionId),240241		/// Variable on chain schema was set242		///243		/// # Arguments244		///245		/// * collection_id: Globally unique collection identifier.246		VariableOnChainSchemaSet(CollectionId),247	}248}249250type SelfWeightOf<T> = <T as Config>::WeightInfo;251252// # Used definitions253//254// ## User control levels255//256// chain-controlled - key is uncontrolled by user257//                    i.e autoincrementing index258//                    can use non-cryptographic hash259// real - key is controlled by user260//        but it is hard to generate enough colliding values, i.e owner of signed txs261//        can use non-cryptographic hash262// controlled - key is completly controlled by users263//              i.e maps with mutable keys264//              should use cryptographic hash265//266// ## User control level downgrade reasons267//268// ?1 - chain-controlled -> controlled269//      collections/tokens can be destroyed, resulting in massive holes270// ?2 - chain-controlled -> controlled271//      same as ?1, but can be only added, resulting in easier exploitation272// ?3 - real -> controlled273//      no confirmation required, so addresses can be easily generated274decl_storage! {275	trait Store for Module<T: Config> as Unique {276277		//#region Private members278		/// Used for migrations279		ChainVersion: u64;280		//#endregion281282		//#region Tokens transfer rate limit baskets283		/// (Collection id (controlled?2), who created (real))284		/// TODO: Off chain worker should remove from this map when collection gets removed285		pub CreateItemBasket get(fn create_item_basket): map hasher(blake2_128_concat) (CollectionId, T::AccountId) => Option<T::BlockNumber>;286		/// Collection id (controlled?2), token id (controlled?2)287		pub NftTransferBasket get(fn nft_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<T::BlockNumber>;288		/// Collection id (controlled?2), owning user (real)289		pub FungibleTransferBasket get(fn fungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => Option<T::BlockNumber>;290		/// Collection id (controlled?2), token id (controlled?2)291		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>;292		//#endregion293294		/// Variable metadata sponsoring295		/// Collection id (controlled?2), token id (controlled?2)296		pub VariableMetaDataBasket get(fn variable_meta_data_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<T::BlockNumber>;297		/// Approval sponsoring298		pub NftApproveBasket get(fn nft_approve_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<T::BlockNumber>;299		pub FungibleApproveBasket get(fn fungible_approve_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => Option<T::BlockNumber>;300		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>;301	}302}303304decl_module! {305	pub struct Module<T: Config> for enum Call306	where307		origin: T::Origin308	{309		type Error = Error<T>;310311		fn deposit_event() = default;312313		fn on_initialize(_now: T::BlockNumber) -> Weight {314			0315		}316317		/// 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.318		///319		/// # Permissions320		///321		/// * Anyone.322		///323		/// # Arguments324		///325		/// * collection_name: UTF-16 string with collection name (limit 64 characters), will be stored as zero-terminated.326		///327		/// * collection_description: UTF-16 string with collection description (limit 256 characters), will be stored as zero-terminated.328		///329		/// * token_prefix: UTF-8 string with token prefix.330		///331		/// * mode: [CollectionMode] collection type and type dependent data.332		// returns collection ID333		#[weight = <SelfWeightOf<T>>::create_collection()]334		#[transactional]335		#[deprecated]336		pub fn create_collection(origin,337								 collection_name: BoundedVec<u16, ConstU32<MAX_COLLECTION_NAME_LENGTH>>,338								 collection_description: BoundedVec<u16, ConstU32<MAX_COLLECTION_DESCRIPTION_LENGTH>>,339								 token_prefix: BoundedVec<u8, ConstU32<MAX_TOKEN_PREFIX_LENGTH>>,340								 mode: CollectionMode) -> DispatchResult  {341			let data: CreateCollectionData<T::AccountId> = CreateCollectionData {342				name: collection_name,343				description: collection_description,344				token_prefix,345				mode,346				..Default::default()347			};348			Self::create_collection_ex(origin, data)349		}350351		/// This method creates a collection352		///353		/// Prefer it to deprecated [`created_collection`] method354		#[weight = <SelfWeightOf<T>>::create_collection()]355		#[transactional]356		pub fn create_collection_ex(origin, data: CreateCollectionData<T::AccountId>) -> DispatchResult {357			let owner = ensure_signed(origin)?;358359			let _id = match data.mode {360				CollectionMode::NFT => {<PalletNonfungible<T>>::init_collection(owner, data)?},361				CollectionMode::Fungible(decimal_points) => {362					// check params363					ensure!(decimal_points <= MAX_DECIMAL_POINTS, Error::<T>::CollectionDecimalPointLimitExceeded);364					<PalletFungible<T>>::init_collection(owner, data)?365				}366				CollectionMode::ReFungible => {367					<PalletRefungible<T>>::init_collection(owner, data)?368				}369			};370371			Ok(())372		}373374		/// **DANGEROUS**: Destroys collection and all NFTs within this collection. Users irrecoverably lose their assets and may lose real money.375		///376		/// # Permissions377		///378		/// * Collection Owner.379		///380		/// # Arguments381		///382		/// * collection_id: collection to destroy.383		#[weight = <SelfWeightOf<T>>::destroy_collection()]384		#[transactional]385		pub fn destroy_collection(origin, collection_id: CollectionId) -> DispatchResult {386			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);387388			let collection = <CollectionHandle<T>>::try_get(collection_id)?;389			collection.check_is_owner(&sender)?;390391			// =========392393			match collection.mode {394				CollectionMode::ReFungible => PalletRefungible::destroy_collection(RefungibleHandle::cast(collection), &sender)?,395				CollectionMode::Fungible(_) => PalletFungible::destroy_collection(FungibleHandle::cast(collection), &sender)?,396				CollectionMode::NFT => PalletNonfungible::destroy_collection(NonfungibleHandle::cast(collection), &sender)?,397			}398399			<NftTransferBasket<T>>::remove_prefix(collection_id, None);400			<FungibleTransferBasket<T>>::remove_prefix(collection_id, None);401			<ReFungibleTransferBasket<T>>::remove_prefix((collection_id,), None);402403			<VariableMetaDataBasket<T>>::remove_prefix(collection_id, None);404			<NftApproveBasket<T>>::remove_prefix(collection_id, None);405			<FungibleApproveBasket<T>>::remove_prefix(collection_id, None);406			<RefungibleApproveBasket<T>>::remove_prefix((collection_id,), None);407408			Ok(())409		}410411		/// Add an address to allow list.412		///413		/// # Permissions414		///415		/// * Collection Owner416		/// * Collection Admin417		///418		/// # Arguments419		///420		/// * collection_id.421		///422		/// * address.423		#[weight = <SelfWeightOf<T>>::add_to_allow_list()]424		#[transactional]425		pub fn add_to_allow_list(origin, collection_id: CollectionId, address: T::CrossAccountId) -> DispatchResult{426427			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);428			let collection = <CollectionHandle<T>>::try_get(collection_id)?;429430			<PalletCommon<T>>::toggle_allowlist(431				&collection,432				&sender,433				&address,434				true,435			)?;436437			Self::deposit_event(Event::<T>::AllowListAddressAdded(438				collection_id,439				address440			));441442			Ok(())443		}444445		/// Remove an address from allow list.446		///447		/// # Permissions448		///449		/// * Collection Owner450		/// * Collection Admin451		///452		/// # Arguments453		///454		/// * collection_id.455		///456		/// * address.457		#[weight = <SelfWeightOf<T>>::remove_from_allow_list()]458		#[transactional]459		pub fn remove_from_allow_list(origin, collection_id: CollectionId, address: T::CrossAccountId) -> DispatchResult{460461			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);462			let collection = <CollectionHandle<T>>::try_get(collection_id)?;463464			<PalletCommon<T>>::toggle_allowlist(465				&collection,466				&sender,467				&address,468				false,469			)?;470471			<Pallet<T>>::deposit_event(Event::<T>::AllowListAddressRemoved(472				collection_id,473				address474			));475476			Ok(())477		}478479		/// Toggle between normal and allow list access for the methods with access for `Anyone`.480		///481		/// # Permissions482		///483		/// * Collection Owner.484		///485		/// # Arguments486		///487		/// * collection_id.488		///489		/// * mode: [AccessMode]490		#[weight = <SelfWeightOf<T>>::set_public_access_mode()]491		#[transactional]492		pub fn set_public_access_mode(origin, collection_id: CollectionId, mode: AccessMode) -> DispatchResult493		{494			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);495496			let mut target_collection = <CollectionHandle<T>>::try_get(collection_id)?;497			target_collection.check_is_owner(&sender)?;498499			target_collection.access = mode.clone();500501			<Pallet<T>>::deposit_event(Event::<T>::PublicAccessModeSet(502				collection_id,503				mode504			));505506			target_collection.save()507		}508509		/// Allows Anyone to create tokens if:510		/// * Allow List is enabled, and511		/// * Address is added to allow list, and512		/// * This method was called with True parameter513		///514		/// # Permissions515		/// * Collection Owner516		///517		/// # Arguments518		///519		/// * collection_id.520		///521		/// * mint_permission: Boolean parameter. If True, allows minting to Anyone with conditions above.522		#[weight = <SelfWeightOf<T>>::set_mint_permission()]523		#[transactional]524		pub fn set_mint_permission(origin, collection_id: CollectionId, mint_permission: bool) -> DispatchResult525		{526			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);527528			let mut target_collection = <CollectionHandle<T>>::try_get(collection_id)?;529			target_collection.check_is_owner(&sender)?;530531			target_collection.mint_mode = mint_permission;532533			<Pallet<T>>::deposit_event(Event::<T>::MintPermissionSet(534				collection_id535			));536537			target_collection.save()538		}539540		/// Change the owner of the collection.541		///542		/// # Permissions543		///544		/// * Collection Owner.545		///546		/// # Arguments547		///548		/// * collection_id.549		///550		/// * new_owner.551		#[weight = <SelfWeightOf<T>>::change_collection_owner()]552		#[transactional]553		pub fn change_collection_owner(origin, collection_id: CollectionId, new_owner: T::AccountId) -> DispatchResult {554555			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);556557			let mut target_collection = <CollectionHandle<T>>::try_get(collection_id)?;558			target_collection.check_is_owner(&sender)?;559560			target_collection.owner = new_owner.clone();561			<Pallet<T>>::deposit_event(Event::<T>::CollectionOwnedChanged(562				collection_id,563				new_owner564			));565566			target_collection.save()567		}568569		/// Adds an admin of the Collection.570		/// 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.571		///572		/// # Permissions573		///574		/// * Collection Owner.575		/// * Collection Admin.576		///577		/// # Arguments578		///579		/// * collection_id: ID of the Collection to add admin for.580		///581		/// * new_admin_id: Address of new admin to add.582		#[weight = <SelfWeightOf<T>>::add_collection_admin()]583		#[transactional]584		pub fn add_collection_admin(origin, collection_id: CollectionId, new_admin_id: T::CrossAccountId) -> DispatchResult {585			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);586			let collection = <CollectionHandle<T>>::try_get(collection_id)?;587588			<Pallet<T>>::deposit_event(Event::<T>::CollectionAdminAdded(589				collection_id,590				new_admin_id.clone()591			));592593			<PalletCommon<T>>::toggle_admin(&collection, &sender, &new_admin_id, true)594		}595596		/// 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.597		///598		/// # Permissions599		///600		/// * Collection Owner.601		/// * Collection Admin.602		///603		/// # Arguments604		///605		/// * collection_id: ID of the Collection to remove admin for.606		///607		/// * account_id: Address of admin to remove.608		#[weight = <SelfWeightOf<T>>::remove_collection_admin()]609		#[transactional]610		pub fn remove_collection_admin(origin, collection_id: CollectionId, account_id: T::CrossAccountId) -> DispatchResult {611			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);612			let collection = <CollectionHandle<T>>::try_get(collection_id)?;613614			<Pallet<T>>::deposit_event(Event::<T>::CollectionAdminRemoved(615				collection_id,616				account_id.clone()617			));618619			<PalletCommon<T>>::toggle_admin(&collection, &sender, &account_id, false)620		}621622		/// # Permissions623		///624		/// * Collection Owner625		///626		/// # Arguments627		///628		/// * collection_id.629		///630		/// * new_sponsor.631		#[weight = <SelfWeightOf<T>>::set_collection_sponsor()]632		#[transactional]633		pub fn set_collection_sponsor(origin, collection_id: CollectionId, new_sponsor: T::AccountId) -> DispatchResult {634			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);635636			let mut target_collection = <CollectionHandle<T>>::try_get(collection_id)?;637			target_collection.check_is_owner(&sender)?;638639			target_collection.sponsorship = SponsorshipState::Unconfirmed(new_sponsor.clone());640641			<Pallet<T>>::deposit_event(Event::<T>::CollectionSponsorSet(642				collection_id,643				new_sponsor644			));645646			target_collection.save()647		}648649		/// # Permissions650		///651		/// * Sponsor.652		///653		/// # Arguments654		///655		/// * collection_id.656		#[weight = <SelfWeightOf<T>>::confirm_sponsorship()]657		#[transactional]658		pub fn confirm_sponsorship(origin, collection_id: CollectionId) -> DispatchResult {659			let sender = ensure_signed(origin)?;660661			let mut target_collection = <CollectionHandle<T>>::try_get(collection_id)?;662			ensure!(663				target_collection.sponsorship.pending_sponsor() == Some(&sender),664				Error::<T>::ConfirmUnsetSponsorFail665			);666667			target_collection.sponsorship = SponsorshipState::Confirmed(sender.clone());668669			<Pallet<T>>::deposit_event(Event::<T>::SponsorshipConfirmed(670				collection_id,671				sender672			));673674			target_collection.save()675		}676677		/// Switch back to pay-per-own-transaction model.678		///679		/// # Permissions680		///681		/// * Collection owner.682		///683		/// # Arguments684		///685		/// * collection_id.686		#[weight = <SelfWeightOf<T>>::remove_collection_sponsor()]687		#[transactional]688		pub fn remove_collection_sponsor(origin, collection_id: CollectionId) -> DispatchResult {689			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);690691			let mut target_collection = <CollectionHandle<T>>::try_get(collection_id)?;692			target_collection.check_is_owner(&sender)?;693694			target_collection.sponsorship = SponsorshipState::Disabled;695696			<Pallet<T>>::deposit_event(Event::<T>::CollectionSponsorRemoved(697				collection_id698			));699			target_collection.save()700		}701702		/// This method creates a concrete instance of NFT Collection created with CreateCollection method.703		///704		/// # Permissions705		///706		/// * Collection Owner.707		/// * Collection Admin.708		/// * Anyone if709		///     * Allow List is enabled, and710		///     * Address is added to allow list, and711		///     * MintPermission is enabled (see SetMintPermission method)712		///713		/// # Arguments714		///715		/// * collection_id: ID of the collection.716		///717		/// * owner: Address, initial owner of the NFT.718		///719		/// * data: Token data to store on chain.720		#[weight = <CommonWeights<T>>::create_item()]721		#[transactional]722		pub fn create_item(origin, collection_id: CollectionId, owner: T::CrossAccountId, data: CreateItemData) -> DispatchResultWithPostInfo {723			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);724725			dispatch_call::<T, _>(collection_id, |d| d.create_item(sender, owner, data))726		}727728		/// This method creates multiple items in a collection created with CreateCollection method.729		///730		/// # Permissions731		///732		/// * Collection Owner.733		/// * Collection Admin.734		/// * Anyone if735		///     * Allow List is enabled, and736		///     * Address is added to allow list, and737		///     * MintPermission is enabled (see SetMintPermission method)738		///739		/// # Arguments740		///741		/// * collection_id: ID of the collection.742		///743		/// * itemsData: Array items properties. Each property is an array of bytes itself, see [create_item].744		///745		/// * owner: Address, initial owner of the NFT.746		#[weight = <CommonWeights<T>>::create_multiple_items(items_data.len() as u32)]747		#[transactional]748		pub fn create_multiple_items(origin, collection_id: CollectionId, owner: T::CrossAccountId, items_data: Vec<CreateItemData>) -> DispatchResultWithPostInfo {749			ensure!(!items_data.is_empty(), Error::<T>::EmptyArgument);750			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);751752			dispatch_call::<T, _>(collection_id, |d| d.create_multiple_items(sender, owner, items_data))753		}754755		#[weight = <CommonWeights<T>>::create_multiple_items_ex(&data)]756		#[transactional]757		pub fn create_multiple_items_ex(origin, collection_id: CollectionId, data: CreateItemExData<T::CrossAccountId>) -> DispatchResultWithPostInfo {758			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);759760			dispatch_call::<T, _>(collection_id, |d| d.create_multiple_items_ex(sender, data))761		}762763		// TODO! transaction weight764765		/// Set transfers_enabled value for particular collection766		///767		/// # Permissions768		///769		/// * Collection Owner.770		///771		/// # Arguments772		///773		/// * collection_id: ID of the collection.774		///775		/// * value: New flag value.776		#[weight = <SelfWeightOf<T>>::set_transfers_enabled_flag()]777		#[transactional]778		pub fn set_transfers_enabled_flag(origin, collection_id: CollectionId, value: bool) -> DispatchResult {779			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);780			let mut target_collection = <CollectionHandle<T>>::try_get(collection_id)?;781			target_collection.check_is_owner(&sender)?;782783			// =========784785			target_collection.limits.transfers_enabled = Some(value);786			target_collection.save()787		}788789		/// Destroys a concrete instance of NFT.790		///791		/// # Permissions792		///793		/// * Collection Owner.794		/// * Collection Admin.795		/// * Current NFT Owner.796		///797		/// # Arguments798		///799		/// * collection_id: ID of the collection.800		///801		/// * item_id: ID of NFT to burn.802		#[weight = <CommonWeights<T>>::burn_item()]803		#[transactional]804		pub fn burn_item(origin, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResultWithPostInfo {805			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);806807			let post_info = dispatch_call::<T, _>(collection_id, |d| d.burn_item(sender, item_id, value))?;808			if value == 1 {809				<NftTransferBasket<T>>::remove(collection_id, item_id);810				<NftApproveBasket<T>>::remove(collection_id, item_id);811			}812			// Those maps should be cleared only if token disappears completly, need to move this part of logic to pallets?813			// <FungibleApproveBasket<T>>::remove(collection_id, sender.as_sub());814			// <RefungibleApproveBasket<T>>::remove((collection_id, item_id, sender.as_sub()));815			Ok(post_info)816		}817818		/// Destroys a concrete instance of NFT on behalf of the owner819		/// See also: [`approve`]820		///821		/// # Permissions822		///823		/// * Collection Owner.824		/// * Collection Admin.825		/// * Current NFT Owner.826		///827		/// # Arguments828		///829		/// * collection_id: ID of the collection.830		///831		/// * item_id: ID of NFT to burn.832		///833		/// * from: owner of item834		#[weight = <CommonWeights<T>>::burn_from()]835		#[transactional]836		pub fn burn_from(origin, collection_id: CollectionId, from: T::CrossAccountId, item_id: TokenId, value: u128) -> DispatchResultWithPostInfo {837			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);838839			dispatch_call::<T, _>(collection_id, |d| d.burn_from(sender, from, item_id, value))840		}841842		/// Change ownership of the token.843		///844		/// # Permissions845		///846		/// * Collection Owner847		/// * Collection Admin848		/// * Current NFT owner849		///850		/// # Arguments851		///852		/// * recipient: Address of token recipient.853		///854		/// * collection_id.855		///856		/// * item_id: ID of the item857		///     * Non-Fungible Mode: Required.858		///     * Fungible Mode: Ignored.859		///     * Re-Fungible Mode: Required.860		///861		/// * value: Amount to transfer.862		///     * Non-Fungible Mode: Ignored863		///     * Fungible Mode: Must specify transferred amount864		///     * Re-Fungible Mode: Must specify transferred portion (between 0 and 1)865		#[weight = <CommonWeights<T>>::transfer()]866		#[transactional]867		pub fn transfer(origin, recipient: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResultWithPostInfo {868			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);869870			dispatch_call::<T, _>(collection_id, |d| d.transfer(sender, recipient, item_id, value))871		}872873		/// Set, change, or remove approved address to transfer the ownership of the NFT.874		///875		/// # Permissions876		///877		/// * Collection Owner878		/// * Collection Admin879		/// * Current NFT owner880		///881		/// # Arguments882		///883		/// * approved: Address that is approved to transfer this NFT or zero (if needed to remove approval).884		///885		/// * collection_id.886		///887		/// * item_id: ID of the item.888		#[weight = <CommonWeights<T>>::approve()]889		#[transactional]890		pub fn approve(origin, spender: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, amount: u128) -> DispatchResultWithPostInfo {891			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);892893			dispatch_call::<T, _>(collection_id, |d| d.approve(sender, spender, item_id, amount))894		}895896		/// 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.897		///898		/// # Permissions899		/// * Collection Owner900		/// * Collection Admin901		/// * Current NFT owner902		/// * Address approved by current NFT owner903		///904		/// # Arguments905		///906		/// * from: Address that owns token.907		///908		/// * recipient: Address of token recipient.909		///910		/// * collection_id.911		///912		/// * item_id: ID of the item.913		///914		/// * value: Amount to transfer.915		#[weight = <CommonWeights<T>>::transfer_from()]916		#[transactional]917		pub fn transfer_from(origin, from: T::CrossAccountId, recipient: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, value: u128 ) -> DispatchResultWithPostInfo {918			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);919920			dispatch_call::<T, _>(collection_id, |d| d.transfer_from(sender, from, recipient, item_id, value))921		}922923		/// Set off-chain data schema.924		///925		/// # Permissions926		///927		/// * Collection Owner928		/// * Collection Admin929		///930		/// # Arguments931		///932		/// * collection_id.933		///934		/// * schema: String representing the offchain data schema.935		#[weight = <CommonWeights<T>>::set_variable_metadata(data.len() as u32)]936		#[transactional]937		pub fn set_variable_meta_data (938			origin,939			collection_id: CollectionId,940			item_id: TokenId,941			data: BoundedVec<u8, CustomDataLimit>,942		) -> DispatchResultWithPostInfo {943			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);944945			dispatch_call::<T, _>(collection_id, |d| d.set_variable_metadata(sender, item_id, data))946		}947948		/// Set meta_update_permission value for particular collection949		///950		/// # Permissions951		///952		/// * Collection Owner.953		///954		/// # Arguments955		///956		/// * collection_id: ID of the collection.957		///958		/// * value: New flag value.959		#[weight = <SelfWeightOf<T>>::set_meta_update_permission_flag()]960		#[transactional]961		pub fn set_meta_update_permission_flag(origin, collection_id: CollectionId, value: MetaUpdatePermission) -> DispatchResult {962			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);963			let mut target_collection = <CollectionHandle<T>>::try_get(collection_id)?;964965			ensure!(966				target_collection.meta_update_permission != MetaUpdatePermission::None,967				<CommonError<T>>::MetadataFlagFrozen,968			);969			target_collection.check_is_owner(&sender)?;970971			target_collection.meta_update_permission = value;972973			target_collection.save()974		}975976		/// Set schema standard977		/// ImageURL978		/// Unique979		///980		/// # Permissions981		///982		/// * Collection Owner983		/// * Collection Admin984		///985		/// # Arguments986		///987		/// * collection_id.988		///989		/// * schema: SchemaVersion: enum990		#[weight = <SelfWeightOf<T>>::set_schema_version()]991		#[transactional]992		pub fn set_schema_version(993			origin,994			collection_id: CollectionId,995			version: SchemaVersion996		) -> DispatchResult {997			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);998			let mut target_collection = <CollectionHandle<T>>::try_get(collection_id)?;999			target_collection.check_is_owner_or_admin(&sender)?;1000			target_collection.schema_version = version;10011002			<Pallet<T>>::deposit_event(Event::<T>::SchemaVersionSet(1003				collection_id1004			));10051006			target_collection.save()1007		}10081009		/// Set off-chain data schema.1010		///1011		/// # Permissions1012		///1013		/// * Collection Owner1014		/// * Collection Admin1015		///1016		/// # Arguments1017		///1018		/// * collection_id.1019		///1020		/// * schema: String representing the offchain data schema.1021		#[weight = <SelfWeightOf<T>>::set_offchain_schema(schema.len() as u32)]1022		#[transactional]1023		pub fn set_offchain_schema(1024			origin,1025			collection_id: CollectionId,1026			schema: BoundedVec<u8, ConstU32<OFFCHAIN_SCHEMA_LIMIT>>,1027		) -> DispatchResult {1028			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1029			let mut target_collection = <CollectionHandle<T>>::try_get(collection_id)?;1030			target_collection.check_is_owner_or_admin(&sender)?;10311032			target_collection.offchain_schema = schema;10331034			<Pallet<T>>::deposit_event(Event::<T>::OffchainSchemaSet(1035				collection_id1036			));10371038			target_collection.save()1039		}10401041		/// Set const on-chain data schema.1042		///1043		/// # Permissions1044		///1045		/// * Collection Owner1046		/// * Collection Admin1047		///1048		/// # Arguments1049		///1050		/// * collection_id.1051		///1052		/// * schema: String representing the const on-chain data schema.1053		#[weight = <SelfWeightOf<T>>::set_const_on_chain_schema(schema.len() as u32)]1054		#[transactional]1055		pub fn set_const_on_chain_schema (1056			origin,1057			collection_id: CollectionId,1058			schema: BoundedVec<u8, ConstU32<CONST_ON_CHAIN_SCHEMA_LIMIT>>1059		) -> DispatchResult {1060			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1061			let mut target_collection = <CollectionHandle<T>>::try_get(collection_id)?;1062			target_collection.check_is_owner_or_admin(&sender)?;10631064			target_collection.const_on_chain_schema = schema;10651066			<Pallet<T>>::deposit_event(Event::<T>::ConstOnChainSchemaSet(1067				collection_id1068			));10691070			target_collection.save()1071		}10721073		/// Set variable on-chain data schema.1074		///1075		/// # Permissions1076		///1077		/// * Collection Owner1078		/// * Collection Admin1079		///1080		/// # Arguments1081		///1082		/// * collection_id.1083		///1084		/// * schema: String representing the variable on-chain data schema.1085		#[weight = <SelfWeightOf<T>>::set_const_on_chain_schema(schema.len() as u32)]1086		#[transactional]1087		pub fn set_variable_on_chain_schema (1088			origin,1089			collection_id: CollectionId,1090			schema: BoundedVec<u8, ConstU32<VARIABLE_ON_CHAIN_SCHEMA_LIMIT>>1091		) -> DispatchResult {1092			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1093			let mut target_collection = <CollectionHandle<T>>::try_get(collection_id)?;1094			target_collection.check_is_owner_or_admin(&sender)?;10951096			target_collection.variable_on_chain_schema = schema;10971098			<Pallet<T>>::deposit_event(Event::<T>::VariableOnChainSchemaSet(1099				collection_id1100			));11011102			target_collection.save()1103		}11041105		#[weight = <SelfWeightOf<T>>::set_collection_limits()]1106		#[transactional]1107		pub fn set_collection_limits(1108			origin,1109			collection_id: CollectionId,1110			new_limit: CollectionLimits,1111		) -> DispatchResult {1112			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1113			let mut target_collection = <CollectionHandle<T>>::try_get(collection_id)?;1114			target_collection.check_is_owner(&sender)?;1115			let old_limit = &target_collection.limits;11161117			target_collection.limits = <PalletCommon<T>>::clamp_limits(target_collection.mode.clone(), &old_limit, new_limit)?;11181119			<Pallet<T>>::deposit_event(Event::<T>::CollectionLimitSet(1120				collection_id1121			));11221123			target_collection.save()1124		}1125	}1126}