git.delta.rocks / unique-network / refs/commits / 2baf5e90622d

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;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;8687decl_error! {88	/// Error for non-fungible-token module.89	pub enum Error for Module<T: Config> {90		/// Decimal_points parameter must be lower than MAX_DECIMAL_POINTS constant, currently it is 30.91		CollectionDecimalPointLimitExceeded,92		/// This address is not set as sponsor, use setCollectionSponsor first.93		ConfirmUnsetSponsorFail,94		/// Length of items properties must be greater than 0.95		EmptyArgument,96	}97}9899pub trait Config:100	system::Config101	+ pallet_evm_coder_substrate::Config102	+ pallet_common::Config103	+ pallet_nonfungible::Config104	+ pallet_refungible::Config105	+ pallet_fungible::Config106	+ Sized107	+ TypeInfo108{109	type Event: From<Event<Self>> + Into<<Self as frame_system::Config>::Event>;110111	/// Weight information for extrinsics in this pallet.112	type WeightInfo: WeightInfo;113}114115decl_event! {116	pub enum Event<T>117	where118		<T as frame_system::Config>::AccountId,119		<T as pallet_common::Config>::CrossAccountId,120	{121		/// Collection sponsor was removed122		///123		/// # Arguments124		///125		/// * collection_id: Globally unique collection identifier.126		CollectionSponsorRemoved(CollectionId),127128		/// Collection admin was added129		///130		/// # Arguments131		///132		/// * collection_id: Globally unique collection identifier.133		///134		/// * admin:  Admin address.135		CollectionAdminAdded(CollectionId, CrossAccountId),136137		/// Collection owned was change138		///139		/// # Arguments140		///141		/// * collection_id: Globally unique collection identifier.142		///143		/// * owner:  New owner address.144		CollectionOwnedChanged(CollectionId, AccountId),145146		/// Collection sponsor was set147		///148		/// # Arguments149		///150		/// * collection_id: Globally unique collection identifier.151		///152		/// * owner:  New sponsor address.153		CollectionSponsorSet(CollectionId, AccountId),154155		/// const on chain schema was set156		///157		/// # Arguments158		///159		/// * collection_id: Globally unique collection identifier.160		ConstOnChainSchemaSet(CollectionId),161162		/// New sponsor was confirm163		///164		/// # Arguments165		///166		/// * collection_id: Globally unique collection identifier.167		///168		/// * sponsor:  New sponsor address.169		SponsorshipConfirmed(CollectionId, AccountId),170171		/// Collection admin was removed172		///173		/// # Arguments174		///175		/// * collection_id: Globally unique collection identifier.176		///177		/// * admin:  Admin address.178		CollectionAdminRemoved(CollectionId, CrossAccountId),179180		/// Address was remove from allow list181		///182		/// # Arguments183		///184		/// * collection_id: Globally unique collection identifier.185		///186		/// * user:  Address.187		AllowListAddressRemoved(CollectionId, CrossAccountId),188189		/// Address was add to allow list190		///191		/// # Arguments192		///193		/// * collection_id: Globally unique collection identifier.194		///195		/// * user:  Address.196		AllowListAddressAdded(CollectionId, CrossAccountId),197198		/// Collection limits was set199		///200		/// # Arguments201		///202		/// * collection_id: Globally unique collection identifier.203		CollectionLimitSet(CollectionId),204205		/// Mint permission	was set206		///207		/// # Arguments208		///209		/// * collection_id: Globally unique collection identifier.210		MintPermissionSet(CollectionId),211212		/// Offchain schema was set213		///214		/// # Arguments215		///216		/// * collection_id: Globally unique collection identifier.217		OffchainSchemaSet(CollectionId),218219		/// Public access mode was set220		///221		/// # Arguments222		///223		/// * collection_id: Globally unique collection identifier.224		///225		/// * mode: New access state.226		PublicAccessModeSet(CollectionId, AccessMode),227228		/// Schema version was set229		///230		/// # Arguments231		///232		/// * collection_id: Globally unique collection identifier.233		SchemaVersionSet(CollectionId),234235		/// Variable on chain schema was set236		///237		/// # Arguments238		///239		/// * collection_id: Globally unique collection identifier.240		VariableOnChainSchemaSet(CollectionId),241	}242}243244type SelfWeightOf<T> = <T as Config>::WeightInfo;245246// # Used definitions247//248// ## User control levels249//250// chain-controlled - key is uncontrolled by user251//                    i.e autoincrementing index252//                    can use non-cryptographic hash253// real - key is controlled by user254//        but it is hard to generate enough colliding values, i.e owner of signed txs255//        can use non-cryptographic hash256// controlled - key is completly controlled by users257//              i.e maps with mutable keys258//              should use cryptographic hash259//260// ## User control level downgrade reasons261//262// ?1 - chain-controlled -> controlled263//      collections/tokens can be destroyed, resulting in massive holes264// ?2 - chain-controlled -> controlled265//      same as ?1, but can be only added, resulting in easier exploitation266// ?3 - real -> controlled267//      no confirmation required, so addresses can be easily generated268decl_storage! {269	trait Store for Module<T: Config> as Unique {270271		//#region Private members272		/// Used for migrations273		ChainVersion: u64;274		//#endregion275276		//#region Tokens transfer rate limit baskets277		/// (Collection id (controlled?2), who created (real))278		/// TODO: Off chain worker should remove from this map when collection gets removed279		pub CreateItemBasket get(fn create_item_basket): map hasher(blake2_128_concat) (CollectionId, T::AccountId) => Option<T::BlockNumber>;280		/// Collection id (controlled?2), token id (controlled?2)281		pub NftTransferBasket get(fn nft_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<T::BlockNumber>;282		/// Collection id (controlled?2), owning user (real)283		pub FungibleTransferBasket get(fn fungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => Option<T::BlockNumber>;284		/// Collection id (controlled?2), token id (controlled?2)285		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>;286		//#endregion287288		/// Variable metadata sponsoring289		/// Collection id (controlled?2), token id (controlled?2)290		pub VariableMetaDataBasket get(fn variable_meta_data_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<T::BlockNumber>;291		/// Approval sponsoring292		pub NftApproveBasket get(fn nft_approve_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<T::BlockNumber>;293		pub FungibleApproveBasket get(fn fungible_approve_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => Option<T::BlockNumber>;294		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>;295	}296}297298decl_module! {299	pub struct Module<T: Config> for enum Call300	where301		origin: T::Origin302	{303		type Error = Error<T>;304305		fn deposit_event() = default;306307		fn on_initialize(_now: T::BlockNumber) -> Weight {308			0309		}310311		/// 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.312		///313		/// # Permissions314		///315		/// * Anyone.316		///317		/// # Arguments318		///319		/// * collection_name: UTF-16 string with collection name (limit 64 characters), will be stored as zero-terminated.320		///321		/// * collection_description: UTF-16 string with collection description (limit 256 characters), will be stored as zero-terminated.322		///323		/// * token_prefix: UTF-8 string with token prefix.324		///325		/// * mode: [CollectionMode] collection type and type dependent data.326		// returns collection ID327		#[weight = <SelfWeightOf<T>>::create_collection()]328		#[transactional]329		#[deprecated]330		pub fn create_collection(origin,331								 collection_name: BoundedVec<u16, ConstU32<MAX_COLLECTION_NAME_LENGTH>>,332								 collection_description: BoundedVec<u16, ConstU32<MAX_COLLECTION_DESCRIPTION_LENGTH>>,333								 token_prefix: BoundedVec<u8, ConstU32<MAX_TOKEN_PREFIX_LENGTH>>,334								 mode: CollectionMode) -> DispatchResult  {335			let data: CreateCollectionData<T::AccountId> = CreateCollectionData {336				name: collection_name,337				description: collection_description,338				token_prefix,339				mode,340				..Default::default()341			};342			Self::create_collection_ex(origin, data)343		}344345		/// This method creates a collection346		///347		/// Prefer it to deprecated [`created_collection`] method348		#[weight = <SelfWeightOf<T>>::create_collection()]349		#[transactional]350		pub fn create_collection_ex(origin, data: CreateCollectionData<T::AccountId>) -> DispatchResult {351			let owner = ensure_signed(origin)?;352353			let _id = match data.mode {354				CollectionMode::NFT => {<PalletNonfungible<T>>::init_collection(owner, data)?},355				CollectionMode::Fungible(decimal_points) => {356					// check params357					ensure!(decimal_points <= MAX_DECIMAL_POINTS, Error::<T>::CollectionDecimalPointLimitExceeded);358					<PalletFungible<T>>::init_collection(owner, data)?359				}360				CollectionMode::ReFungible => {361					<PalletRefungible<T>>::init_collection(owner, data)?362				}363			};364365			Ok(())366		}367368		/// **DANGEROUS**: Destroys collection and all NFTs within this collection. Users irrecoverably lose their assets and may lose real money.369		///370		/// # Permissions371		///372		/// * Collection Owner.373		///374		/// # Arguments375		///376		/// * collection_id: collection to destroy.377		#[weight = <SelfWeightOf<T>>::destroy_collection()]378		#[transactional]379		pub fn destroy_collection(origin, collection_id: CollectionId) -> DispatchResult {380			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);381382			let collection = <CollectionHandle<T>>::try_get(collection_id)?;383			collection.check_is_owner(&sender)?;384385			// =========386387			match collection.mode {388				CollectionMode::ReFungible => PalletRefungible::destroy_collection(RefungibleHandle::cast(collection), &sender)?,389				CollectionMode::Fungible(_) => PalletFungible::destroy_collection(FungibleHandle::cast(collection), &sender)?,390				CollectionMode::NFT => PalletNonfungible::destroy_collection(NonfungibleHandle::cast(collection), &sender)?,391			}392393			<NftTransferBasket<T>>::remove_prefix(collection_id, None);394			<FungibleTransferBasket<T>>::remove_prefix(collection_id, None);395			<ReFungibleTransferBasket<T>>::remove_prefix((collection_id,), None);396397			<VariableMetaDataBasket<T>>::remove_prefix(collection_id, None);398			<NftApproveBasket<T>>::remove_prefix(collection_id, None);399			<FungibleApproveBasket<T>>::remove_prefix(collection_id, None);400			<RefungibleApproveBasket<T>>::remove_prefix((collection_id,), None);401402			Ok(())403		}404405		/// Add an address to allow list.406		///407		/// # Permissions408		///409		/// * Collection Owner410		/// * Collection Admin411		///412		/// # Arguments413		///414		/// * collection_id.415		///416		/// * address.417		#[weight = <SelfWeightOf<T>>::add_to_allow_list()]418		#[transactional]419		pub fn add_to_allow_list(origin, collection_id: CollectionId, address: T::CrossAccountId) -> DispatchResult{420421			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);422			let collection = <CollectionHandle<T>>::try_get(collection_id)?;423424			<PalletCommon<T>>::toggle_allowlist(425				&collection,426				&sender,427				&address,428				true,429			)?;430431			Self::deposit_event(Event::<T>::AllowListAddressAdded(432				collection_id,433				address434			));435436			Ok(())437		}438439		/// Remove an address from allow list.440		///441		/// # Permissions442		///443		/// * Collection Owner444		/// * Collection Admin445		///446		/// # Arguments447		///448		/// * collection_id.449		///450		/// * address.451		#[weight = <SelfWeightOf<T>>::remove_from_allow_list()]452		#[transactional]453		pub fn remove_from_allow_list(origin, collection_id: CollectionId, address: T::CrossAccountId) -> DispatchResult{454455			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);456			let collection = <CollectionHandle<T>>::try_get(collection_id)?;457458			<PalletCommon<T>>::toggle_allowlist(459				&collection,460				&sender,461				&address,462				false,463			)?;464465			<Pallet<T>>::deposit_event(Event::<T>::AllowListAddressRemoved(466				collection_id,467				address468			));469470			Ok(())471		}472473		/// Toggle between normal and allow list access for the methods with access for `Anyone`.474		///475		/// # Permissions476		///477		/// * Collection Owner.478		///479		/// # Arguments480		///481		/// * collection_id.482		///483		/// * mode: [AccessMode]484		#[weight = <SelfWeightOf<T>>::set_public_access_mode()]485		#[transactional]486		pub fn set_public_access_mode(origin, collection_id: CollectionId, mode: AccessMode) -> DispatchResult487		{488			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);489490			let mut target_collection = <CollectionHandle<T>>::try_get(collection_id)?;491			target_collection.check_is_owner(&sender)?;492493			target_collection.access = mode.clone();494495			<Pallet<T>>::deposit_event(Event::<T>::PublicAccessModeSet(496				collection_id,497				mode498			));499500			target_collection.save()501		}502503		/// Allows Anyone to create tokens if:504		/// * Allow List is enabled, and505		/// * Address is added to allow list, and506		/// * This method was called with True parameter507		///508		/// # Permissions509		/// * Collection Owner510		///511		/// # Arguments512		///513		/// * collection_id.514		///515		/// * mint_permission: Boolean parameter. If True, allows minting to Anyone with conditions above.516		#[weight = <SelfWeightOf<T>>::set_mint_permission()]517		#[transactional]518		pub fn set_mint_permission(origin, collection_id: CollectionId, mint_permission: bool) -> DispatchResult519		{520			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);521522			let mut target_collection = <CollectionHandle<T>>::try_get(collection_id)?;523			target_collection.check_is_owner(&sender)?;524525			target_collection.mint_mode = mint_permission;526527			<Pallet<T>>::deposit_event(Event::<T>::MintPermissionSet(528				collection_id529			));530531			target_collection.save()532		}533534		/// Change the owner of the collection.535		///536		/// # Permissions537		///538		/// * Collection Owner.539		///540		/// # Arguments541		///542		/// * collection_id.543		///544		/// * new_owner.545		#[weight = <SelfWeightOf<T>>::change_collection_owner()]546		#[transactional]547		pub fn change_collection_owner(origin, collection_id: CollectionId, new_owner: T::AccountId) -> DispatchResult {548549			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);550551			let mut target_collection = <CollectionHandle<T>>::try_get(collection_id)?;552			target_collection.check_is_owner(&sender)?;553554			target_collection.owner = new_owner.clone();555			<Pallet<T>>::deposit_event(Event::<T>::CollectionOwnedChanged(556				collection_id,557				new_owner558			));559560			target_collection.save()561		}562563		/// Adds an admin of the Collection.564		/// 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.565		///566		/// # Permissions567		///568		/// * Collection Owner.569		/// * Collection Admin.570		///571		/// # Arguments572		///573		/// * collection_id: ID of the Collection to add admin for.574		///575		/// * new_admin_id: Address of new admin to add.576		#[weight = <SelfWeightOf<T>>::add_collection_admin()]577		#[transactional]578		pub fn add_collection_admin(origin, collection_id: CollectionId, new_admin_id: T::CrossAccountId) -> DispatchResult {579			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);580			let collection = <CollectionHandle<T>>::try_get(collection_id)?;581582			<Pallet<T>>::deposit_event(Event::<T>::CollectionAdminAdded(583				collection_id,584				new_admin_id.clone()585			));586587			<PalletCommon<T>>::toggle_admin(&collection, &sender, &new_admin_id, true)588		}589590		/// 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.591		///592		/// # Permissions593		///594		/// * Collection Owner.595		/// * Collection Admin.596		///597		/// # Arguments598		///599		/// * collection_id: ID of the Collection to remove admin for.600		///601		/// * account_id: Address of admin to remove.602		#[weight = <SelfWeightOf<T>>::remove_collection_admin()]603		#[transactional]604		pub fn remove_collection_admin(origin, collection_id: CollectionId, account_id: T::CrossAccountId) -> DispatchResult {605			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);606			let collection = <CollectionHandle<T>>::try_get(collection_id)?;607608			<Pallet<T>>::deposit_event(Event::<T>::CollectionAdminRemoved(609				collection_id,610				account_id.clone()611			));612613			<PalletCommon<T>>::toggle_admin(&collection, &sender, &account_id, false)614		}615616		/// # Permissions617		///618		/// * Collection Owner619		///620		/// # Arguments621		///622		/// * collection_id.623		///624		/// * new_sponsor.625		#[weight = <SelfWeightOf<T>>::set_collection_sponsor()]626		#[transactional]627		pub fn set_collection_sponsor(origin, collection_id: CollectionId, new_sponsor: T::AccountId) -> DispatchResult {628			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);629630			let mut target_collection = <CollectionHandle<T>>::try_get(collection_id)?;631			target_collection.check_is_owner(&sender)?;632633			target_collection.sponsorship = SponsorshipState::Unconfirmed(new_sponsor.clone());634635			<Pallet<T>>::deposit_event(Event::<T>::CollectionSponsorSet(636				collection_id,637				new_sponsor638			));639640			target_collection.save()641		}642643		/// # Permissions644		///645		/// * Sponsor.646		///647		/// # Arguments648		///649		/// * collection_id.650		#[weight = <SelfWeightOf<T>>::confirm_sponsorship()]651		#[transactional]652		pub fn confirm_sponsorship(origin, collection_id: CollectionId) -> DispatchResult {653			let sender = ensure_signed(origin)?;654655			let mut target_collection = <CollectionHandle<T>>::try_get(collection_id)?;656			ensure!(657				target_collection.sponsorship.pending_sponsor() == Some(&sender),658				Error::<T>::ConfirmUnsetSponsorFail659			);660661			target_collection.sponsorship = SponsorshipState::Confirmed(sender.clone());662663			<Pallet<T>>::deposit_event(Event::<T>::SponsorshipConfirmed(664				collection_id,665				sender666			));667668			target_collection.save()669		}670671		/// Switch back to pay-per-own-transaction model.672		///673		/// # Permissions674		///675		/// * Collection owner.676		///677		/// # Arguments678		///679		/// * collection_id.680		#[weight = <SelfWeightOf<T>>::remove_collection_sponsor()]681		#[transactional]682		pub fn remove_collection_sponsor(origin, collection_id: CollectionId) -> DispatchResult {683			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);684685			let mut target_collection = <CollectionHandle<T>>::try_get(collection_id)?;686			target_collection.check_is_owner(&sender)?;687688			target_collection.sponsorship = SponsorshipState::Disabled;689690			<Pallet<T>>::deposit_event(Event::<T>::CollectionSponsorRemoved(691				collection_id692			));693			target_collection.save()694		}695696		/// This method creates a concrete instance of NFT Collection created with CreateCollection method.697		///698		/// # Permissions699		///700		/// * Collection Owner.701		/// * Collection Admin.702		/// * Anyone if703		///     * Allow List is enabled, and704		///     * Address is added to allow list, and705		///     * MintPermission is enabled (see SetMintPermission method)706		///707		/// # Arguments708		///709		/// * collection_id: ID of the collection.710		///711		/// * owner: Address, initial owner of the NFT.712		///713		/// * data: Token data to store on chain.714		#[weight = <CommonWeights<T>>::create_item()]715		#[transactional]716		pub fn create_item(origin, collection_id: CollectionId, owner: T::CrossAccountId, data: CreateItemData) -> DispatchResultWithPostInfo {717			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);718719			dispatch_call::<T, _>(collection_id, |d| d.create_item(sender, owner, data))720		}721722		/// This method creates multiple items in a collection created with CreateCollection method.723		///724		/// # Permissions725		///726		/// * Collection Owner.727		/// * Collection Admin.728		/// * Anyone if729		///     * Allow List is enabled, and730		///     * Address is added to allow list, and731		///     * MintPermission is enabled (see SetMintPermission method)732		///733		/// # Arguments734		///735		/// * collection_id: ID of the collection.736		///737		/// * itemsData: Array items properties. Each property is an array of bytes itself, see [create_item].738		///739		/// * owner: Address, initial owner of the NFT.740		#[weight = <CommonWeights<T>>::create_multiple_items(items_data.len() as u32)]741		#[transactional]742		pub fn create_multiple_items(origin, collection_id: CollectionId, owner: T::CrossAccountId, items_data: Vec<CreateItemData>) -> DispatchResultWithPostInfo {743			ensure!(!items_data.is_empty(), Error::<T>::EmptyArgument);744			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);745746			dispatch_call::<T, _>(collection_id, |d| d.create_multiple_items(sender, owner, items_data))747		}748749		#[weight = <CommonWeights<T>>::create_multiple_items_ex(&data)]750		#[transactional]751		pub fn create_multiple_items_ex(origin, collection_id: CollectionId, data: CreateItemExData<T::CrossAccountId>) -> DispatchResultWithPostInfo {752			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);753754			dispatch_call::<T, _>(collection_id, |d| d.create_multiple_items_ex(sender, data))755		}756757		// TODO! transaction weight758759		/// Set transfers_enabled value for particular collection760		///761		/// # Permissions762		///763		/// * Collection Owner.764		///765		/// # Arguments766		///767		/// * collection_id: ID of the collection.768		///769		/// * value: New flag value.770		#[weight = <SelfWeightOf<T>>::set_transfers_enabled_flag()]771		#[transactional]772		pub fn set_transfers_enabled_flag(origin, collection_id: CollectionId, value: bool) -> DispatchResult {773			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);774			let mut target_collection = <CollectionHandle<T>>::try_get(collection_id)?;775			target_collection.check_is_owner(&sender)?;776777			// =========778779			target_collection.limits.transfers_enabled = Some(value);780			target_collection.save()781		}782783		/// Destroys a concrete instance of NFT.784		///785		/// # Permissions786		///787		/// * Collection Owner.788		/// * Collection Admin.789		/// * Current NFT Owner.790		///791		/// # Arguments792		///793		/// * collection_id: ID of the collection.794		///795		/// * item_id: ID of NFT to burn.796		#[weight = <CommonWeights<T>>::burn_item()]797		#[transactional]798		pub fn burn_item(origin, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResultWithPostInfo {799			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);800801			let post_info = dispatch_call::<T, _>(collection_id, |d| d.burn_item(sender, item_id, value))?;802			if value == 1 {803				<NftTransferBasket<T>>::remove(collection_id, item_id);804				<NftApproveBasket<T>>::remove(collection_id, item_id);805			}806			// Those maps should be cleared only if token disappears completly, need to move this part of logic to pallets?807			// <FungibleApproveBasket<T>>::remove(collection_id, sender.as_sub());808			// <RefungibleApproveBasket<T>>::remove((collection_id, item_id, sender.as_sub()));809			Ok(post_info)810		}811812		/// Destroys a concrete instance of NFT on behalf of the owner813		/// See also: [`approve`]814		///815		/// # Permissions816		///817		/// * Collection Owner.818		/// * Collection Admin.819		/// * Current NFT Owner.820		///821		/// # Arguments822		///823		/// * collection_id: ID of the collection.824		///825		/// * item_id: ID of NFT to burn.826		///827		/// * from: owner of item828		#[weight = <CommonWeights<T>>::burn_from()]829		#[transactional]830		pub fn burn_from(origin, collection_id: CollectionId, from: T::CrossAccountId, item_id: TokenId, value: u128) -> DispatchResultWithPostInfo {831			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);832833			dispatch_call::<T, _>(collection_id, |d| d.burn_from(sender, from, item_id, value))834		}835836		/// Change ownership of the token.837		///838		/// # Permissions839		///840		/// * Collection Owner841		/// * Collection Admin842		/// * Current NFT owner843		///844		/// # Arguments845		///846		/// * recipient: Address of token recipient.847		///848		/// * collection_id.849		///850		/// * item_id: ID of the item851		///     * Non-Fungible Mode: Required.852		///     * Fungible Mode: Ignored.853		///     * Re-Fungible Mode: Required.854		///855		/// * value: Amount to transfer.856		///     * Non-Fungible Mode: Ignored857		///     * Fungible Mode: Must specify transferred amount858		///     * Re-Fungible Mode: Must specify transferred portion (between 0 and 1)859		#[weight = <CommonWeights<T>>::transfer()]860		#[transactional]861		pub fn transfer(origin, recipient: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResultWithPostInfo {862			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);863864			dispatch_call::<T, _>(collection_id, |d| d.transfer(sender, recipient, item_id, value))865		}866867		/// Set, change, or remove approved address to transfer the ownership of the NFT.868		///869		/// # Permissions870		///871		/// * Collection Owner872		/// * Collection Admin873		/// * Current NFT owner874		///875		/// # Arguments876		///877		/// * approved: Address that is approved to transfer this NFT or zero (if needed to remove approval).878		///879		/// * collection_id.880		///881		/// * item_id: ID of the item.882		#[weight = <CommonWeights<T>>::approve()]883		#[transactional]884		pub fn approve(origin, spender: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, amount: u128) -> DispatchResultWithPostInfo {885			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);886887			dispatch_call::<T, _>(collection_id, |d| d.approve(sender, spender, item_id, amount))888		}889890		/// 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.891		///892		/// # Permissions893		/// * Collection Owner894		/// * Collection Admin895		/// * Current NFT owner896		/// * Address approved by current NFT owner897		///898		/// # Arguments899		///900		/// * from: Address that owns token.901		///902		/// * recipient: Address of token recipient.903		///904		/// * collection_id.905		///906		/// * item_id: ID of the item.907		///908		/// * value: Amount to transfer.909		#[weight = <CommonWeights<T>>::transfer_from()]910		#[transactional]911		pub fn transfer_from(origin, from: T::CrossAccountId, recipient: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, value: u128 ) -> DispatchResultWithPostInfo {912			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);913914			dispatch_call::<T, _>(collection_id, |d| d.transfer_from(sender, from, recipient, item_id, value))915		}916917		/// Set off-chain data schema.918		///919		/// # Permissions920		///921		/// * Collection Owner922		/// * Collection Admin923		///924		/// # Arguments925		///926		/// * collection_id.927		///928		/// * schema: String representing the offchain data schema.929		#[weight = <CommonWeights<T>>::set_variable_metadata(data.len() as u32)]930		#[transactional]931		pub fn set_variable_meta_data (932			origin,933			collection_id: CollectionId,934			item_id: TokenId,935			data: BoundedVec<u8, CustomDataLimit>,936		) -> DispatchResultWithPostInfo {937			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);938939			dispatch_call::<T, _>(collection_id, |d| d.set_variable_metadata(sender, item_id, data))940		}941942		/// Set meta_update_permission value for particular collection943		///944		/// # Permissions945		///946		/// * Collection Owner.947		///948		/// # Arguments949		///950		/// * collection_id: ID of the collection.951		///952		/// * value: New flag value.953		#[weight = <SelfWeightOf<T>>::set_meta_update_permission_flag()]954		#[transactional]955		pub fn set_meta_update_permission_flag(origin, collection_id: CollectionId, value: MetaUpdatePermission) -> DispatchResult {956			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);957			let mut target_collection = <CollectionHandle<T>>::try_get(collection_id)?;958959			ensure!(960				target_collection.meta_update_permission != MetaUpdatePermission::None,961				<CommonError<T>>::MetadataFlagFrozen,962			);963			target_collection.check_is_owner(&sender)?;964965			target_collection.meta_update_permission = value;966967			target_collection.save()968		}969970		/// Set schema standard971		/// ImageURL972		/// Unique973		///974		/// # Permissions975		///976		/// * Collection Owner977		/// * Collection Admin978		///979		/// # Arguments980		///981		/// * collection_id.982		///983		/// * schema: SchemaVersion: enum984		#[weight = <SelfWeightOf<T>>::set_schema_version()]985		#[transactional]986		pub fn set_schema_version(987			origin,988			collection_id: CollectionId,989			version: SchemaVersion990		) -> DispatchResult {991			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);992			let mut target_collection = <CollectionHandle<T>>::try_get(collection_id)?;993			target_collection.check_is_owner_or_admin(&sender)?;994			target_collection.schema_version = version;995996			<Pallet<T>>::deposit_event(Event::<T>::SchemaVersionSet(997				collection_id998			));9991000			target_collection.save()1001		}10021003		/// Set off-chain data schema.1004		///1005		/// # Permissions1006		///1007		/// * Collection Owner1008		/// * Collection Admin1009		///1010		/// # Arguments1011		///1012		/// * collection_id.1013		///1014		/// * schema: String representing the offchain data schema.1015		#[weight = <SelfWeightOf<T>>::set_offchain_schema(schema.len() as u32)]1016		#[transactional]1017		pub fn set_offchain_schema(1018			origin,1019			collection_id: CollectionId,1020			schema: BoundedVec<u8, ConstU32<OFFCHAIN_SCHEMA_LIMIT>>,1021		) -> DispatchResult {1022			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1023			let mut target_collection = <CollectionHandle<T>>::try_get(collection_id)?;1024			target_collection.check_is_owner_or_admin(&sender)?;10251026			target_collection.offchain_schema = schema;10271028			<Pallet<T>>::deposit_event(Event::<T>::OffchainSchemaSet(1029				collection_id1030			));10311032			target_collection.save()1033		}10341035		/// Set const on-chain data schema.1036		///1037		/// # Permissions1038		///1039		/// * Collection Owner1040		/// * Collection Admin1041		///1042		/// # Arguments1043		///1044		/// * collection_id.1045		///1046		/// * schema: String representing the const on-chain data schema.1047		#[weight = <SelfWeightOf<T>>::set_const_on_chain_schema(schema.len() as u32)]1048		#[transactional]1049		pub fn set_const_on_chain_schema (1050			origin,1051			collection_id: CollectionId,1052			schema: BoundedVec<u8, ConstU32<CONST_ON_CHAIN_SCHEMA_LIMIT>>1053		) -> DispatchResult {1054			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1055			let mut target_collection = <CollectionHandle<T>>::try_get(collection_id)?;1056			target_collection.check_is_owner_or_admin(&sender)?;10571058			target_collection.const_on_chain_schema = schema;10591060			<Pallet<T>>::deposit_event(Event::<T>::ConstOnChainSchemaSet(1061				collection_id1062			));10631064			target_collection.save()1065		}10661067		/// Set variable on-chain data schema.1068		///1069		/// # Permissions1070		///1071		/// * Collection Owner1072		/// * Collection Admin1073		///1074		/// # Arguments1075		///1076		/// * collection_id.1077		///1078		/// * schema: String representing the variable on-chain data schema.1079		#[weight = <SelfWeightOf<T>>::set_const_on_chain_schema(schema.len() as u32)]1080		#[transactional]1081		pub fn set_variable_on_chain_schema (1082			origin,1083			collection_id: CollectionId,1084			schema: BoundedVec<u8, ConstU32<VARIABLE_ON_CHAIN_SCHEMA_LIMIT>>1085		) -> DispatchResult {1086			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1087			let mut target_collection = <CollectionHandle<T>>::try_get(collection_id)?;1088			target_collection.check_is_owner_or_admin(&sender)?;10891090			target_collection.variable_on_chain_schema = schema;10911092			<Pallet<T>>::deposit_event(Event::<T>::VariableOnChainSchemaSet(1093				collection_id1094			));10951096			target_collection.save()1097		}10981099		#[weight = <SelfWeightOf<T>>::set_collection_limits()]1100		#[transactional]1101		pub fn set_collection_limits(1102			origin,1103			collection_id: CollectionId,1104			new_limit: CollectionLimits,1105		) -> DispatchResult {1106			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1107			let mut target_collection = <CollectionHandle<T>>::try_get(collection_id)?;1108			target_collection.check_is_owner(&sender)?;1109			let old_limit = &target_collection.limits;11101111			target_collection.limits = <PalletCommon<T>>::clamp_limits(target_collection.mode.clone(), &old_limit, new_limit)?;11121113			<Pallet<T>>::deposit_event(Event::<T>::CollectionLimitSet(1114				collection_id1115			));11161117			target_collection.save()1118		}1119	}1120}