git.delta.rocks / unique-network / refs/commits / 71e3eed44117

1#![cfg_attr(not(feature = "std"), no_std)]23#[cfg(feature = "std")]4pub use std::*;56#[cfg(feature = "std")]7pub use serde::*;89use codec::{Decode, Encode};10pub use frame_support::{11    construct_runtime, decl_event, decl_module, decl_storage, decl_error,12    dispatch::DispatchResult,13    ensure, fail, parameter_types,14    traits::{15        Currency, ExistenceRequirement, Get, Imbalance, KeyOwnerProofSystem, OnUnbalanced,16        Randomness, WithdrawReason,17    },18    weights::{19        constants::{BlockExecutionWeight, ExtrinsicBaseWeight, RocksDbWeight, WEIGHT_PER_SECOND},20        DispatchInfo, GetDispatchInfo, IdentityFee, Pays, PostDispatchInfo, Weight,21        WeightToFeePolynomial,22    },23    IsSubType, StorageValue,24};2526use frame_system::{self as system, ensure_signed, ensure_root};27use sp_runtime::sp_std::prelude::Vec;28use sp_runtime::{29    traits::{30        DispatchInfoOf, Dispatchable, PostDispatchInfoOf, Saturating, SignedExtension, Zero,31    },32    transaction_validity::{33        InvalidTransaction, TransactionValidity, TransactionValidityError, ValidTransaction,34    },35    FixedPointOperand, FixedU128,36};37use pallet_contracts::ContractAddressFor;38use sp_runtime::traits::StaticLookup;3940#[cfg(test)]41mod mock;4243#[cfg(test)]44mod tests;4546mod default_weights;4748// Structs49// #region5051#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq)]52#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]53pub enum CollectionMode {54    Invalid,55    NFT,56    // decimal points57    Fungible(u32),58    // decimal points59    ReFungible(u32),60}6162impl Into<u8> for CollectionMode {63    fn into(self) -> u8 {64        match self {65            CollectionMode::Invalid => 0,66            CollectionMode::NFT => 1,67            CollectionMode::Fungible(_) => 2,68            CollectionMode::ReFungible(_) => 3,69        }70    }71}7273#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq)]74#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]75pub enum AccessMode {76    Normal,77    WhiteList,78}79impl Default for AccessMode {80    fn default() -> Self {81        Self::Normal82    }83}8485impl Default for CollectionMode {86    fn default() -> Self {87        Self::Invalid88    }89}9091#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]92#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]93pub struct Ownership<AccountId> {94    pub owner: AccountId,95    pub fraction: u128,96}9798#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]99#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]100pub struct CollectionType<AccountId> {101    pub owner: AccountId,102    pub mode: CollectionMode,103    pub access: AccessMode,104    pub decimal_points: u32,105    pub name: Vec<u16>,        // 64 include null escape char106    pub description: Vec<u16>, // 256 include null escape char107    pub token_prefix: Vec<u8>, // 16 include null escape char108    pub mint_mode: bool,109    pub offchain_schema: Vec<u8>,110    pub sponsor: AccountId, // Who pays fees. If set to default address, the fees are applied to the transaction sender111    pub unconfirmed_sponsor: AccountId, // Sponsor address that has not yet confirmed sponsorship112    pub variable_on_chain_schema: Vec<u8>, //113    pub const_on_chain_schema: Vec<u8>, //114}115116#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]117#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]118pub struct NftItemType<AccountId> {119    pub collection: u64,120    pub owner: AccountId,121    pub const_data: Vec<u8>,122    pub variable_data: Vec<u8>,123}124125#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]126#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]127pub struct FungibleItemType<AccountId> {128    pub collection: u64,129    pub owner: AccountId,130    pub value: u128,131}132133#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]134#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]135pub struct ReFungibleItemType<AccountId> {136    pub collection: u64,137    pub owner: Vec<Ownership<AccountId>>,138    pub const_data: Vec<u8>,139    pub variable_data: Vec<u8>,140}141142#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]143#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]144pub struct ApprovePermissions<AccountId> {145    pub approved: AccountId,146    pub amount: u64,147}148149#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]150#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]151pub struct VestingItem<AccountId, Moment> {152    pub sender: AccountId,153    pub recipient: AccountId,154    pub collection_id: u64,155    pub item_id: u64,156    pub amount: u64,157    pub vesting_date: Moment,158}159160#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]161#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]162pub struct BasketItem<AccountId, BlockNumber> {163    pub address: AccountId,164    pub start_block: BlockNumber,165}166167#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]168#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]169pub struct ChainLimits {170    pub collection_numbers_limit: u64,171    pub account_token_ownership_limit: u64,172    pub collections_admins_limit: u64,173    pub custom_data_limit: u32,174175    // Timeouts for item types in passed blocks176    pub nft_sponsor_transfer_timeout: u32,177    pub fungible_sponsor_transfer_timeout: u32,178    pub refungible_sponsor_transfer_timeout: u32,179}180181pub trait WeightInfo {182	fn create_collection() -> Weight;183	fn destroy_collection() -> Weight;184	fn add_to_white_list() -> Weight;185	fn remove_from_white_list() -> Weight;186    fn set_public_access_mode() -> Weight;187    fn set_mint_permission() -> Weight;188    fn change_collection_owner() -> Weight;189    fn add_collection_admin() -> Weight;190    fn remove_collection_admin() -> Weight;191    fn set_collection_sponsor() -> Weight;192    fn confirm_sponsorship() -> Weight;193    fn remove_collection_sponsor() -> Weight;194    fn create_item(s: usize) -> Weight;195    fn burn_item() -> Weight;196    fn transfer() -> Weight;197    fn approve() -> Weight;198    fn transfer_from() -> Weight;199    fn set_offchain_schema() -> Weight;200    fn set_const_on_chain_schema() -> Weight;201    fn set_variable_on_chain_schema() -> Weight;202    fn set_variable_meta_data() -> Weight;203    fn enable_contract_sponsoring() -> Weight;204}205206#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]207#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]208pub struct CreateNftData {209    pub const_data: Vec<u8>,210    pub variable_data: Vec<u8>,211}212213#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]214#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]215pub struct CreateFungibleData {216}217218#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]219#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]220pub struct CreateReFungibleData {221    pub const_data: Vec<u8>,222    pub variable_data: Vec<u8>,223}224225#[derive(Encode, Decode, Debug, Clone, PartialEq)]226#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]227pub enum CreateItemData {228    NFT(CreateNftData),229    Fungible(CreateFungibleData),230    ReFungible(CreateReFungibleData)231}232233impl CreateItemData {234    pub fn len(&self) -> usize {235        let len = match self {236            CreateItemData::NFT(data) => data.variable_data.len() + data.const_data.len(),237            CreateItemData::ReFungible(data) => data.variable_data.len() + data.const_data.len(),238            _ => 0239        };240        241        return len;242    }243}244245impl From<CreateNftData> for CreateItemData {246    fn from(item: CreateNftData) -> Self {247        CreateItemData::NFT(item)248    }249}250251impl From<CreateReFungibleData> for CreateItemData {252    fn from(item: CreateReFungibleData) -> Self {253        CreateItemData::ReFungible(item)254    }255}256257impl From<CreateFungibleData> for CreateItemData {258    fn from(item: CreateFungibleData) -> Self {259        CreateItemData::Fungible(item)260    }261}262263264decl_error! {265	/// Error for non-fungible-token module.266	pub enum Error for Module<T: Trait> {267        /// Total collections bound exceeded.268        TotalCollectionsLimitExceeded,269		/// Decimal_points parameter must be lower than 4.270        CollectionDecimalPointLimitExceeded, 271        /// Collection name can not be longer than 63 char.272        CollectionNameLimitExceeded, 273        /// Collection description can not be longer than 255 char.274        CollectionDescriptionLimitExceeded, 275        /// Token prefix can not be longer than 15 char.276        CollectionTokenPrefixLimitExceeded,277        /// This collection does not exist.278        CollectionNotFound,279        /// Item not exists.280        TokenNotFound,281        /// Arithmetic calculation overflow.282        NumOverflow,       283        /// Account already has admin role.284        AlreadyAdmin,  285        /// You do not own this collection.286        NoPermission,287        /// This address is not set as sponsor, use setCollectionSponsor first.288        ConfirmUnsetSponsorFail,289        /// Collection is not in mint mode.290        PublicMintingNotAllowed,291        /// Sender parameter and item owner must be equal.292        MustBeTokenOwner,293        /// Item balance not enough.294        TokenValueTooLow,295        /// Size of item is too large.296        NftSizeLimitExceeded,297        /// No approve found298        ApproveNotFound,299        /// Requested value more than approved.300        TokenValueNotEnough,301        /// Only approved addresses can call this method.302        ApproveRequired,303        /// Address is not in white list.304        AddresNotInWhiteList,305        /// Number of collection admins bound exceeded.306        CollectionAdminsLimitExceeded,307        /// Owned tokens by a single address bound exceeded.308        AddressOwnershipLimitExceeded,309        /// Length of items properties must be greater than 0.310        EmptyArgument,311        /// const_data exceeded data limit.312        TokenConstDataLimitExceeded,313        /// variable_data exceeded data limit.314        TokenVariableDataLimitExceeded,315        /// Not NFT item data used to mint in NFT collection.316        NotNftDataUsedToMintNftCollectionToken,317        /// Not Fungible item data used to mint in Fungible collection.318        NotFungibleDataUsedToMintFungibleCollectionToken,319        /// Not Re Fungible item data used to mint in Re Fungible collection.320        NotReFungibleDataUsedToMintReFungibleCollectionToken,321        /// Unexpected collection type.322        UnexpectedCollectionType,323        /// Can't store metadata in fungible tokens.324        CantStoreMetadataInFungibleTokens325	}326}327328pub trait Trait: system::Trait + Sized + transaction_payment::Trait + pallet_contracts::Trait {329    type Event: From<Event<Self>> + Into<<Self as system::Trait>::Event>;330331    /// Weight information for extrinsics in this pallet.332	type WeightInfo: WeightInfo;333}334335#[cfg(feature = "runtime-benchmarks")]336mod benchmarking;337338// #endregion339340decl_storage! {341    trait Store for Module<T: Trait> as Nft {342343        // Private members344        NextCollectionID: u64;345        CreatedCollectionCount: u64;346        ChainVersion: u64;347        ItemListIndex: map hasher(blake2_128_concat) u64 => u64;348349        // Chain limits struct350        pub ChainLimit get(fn chain_limit) config(): ChainLimits;351352        // Bound counters353        CollectionCount: u64;354        pub AccountItemCount get(fn account_item_count): map hasher(identity) T::AccountId => u64;355356        // Basic collections357        pub Collection get(fn collection) config(): map hasher(identity) u64 => CollectionType<T::AccountId>;358        pub AdminList get(fn admin_list_collection): map hasher(identity) u64 => Vec<T::AccountId>;359        pub WhiteList get(fn white_list): map hasher(identity) u64 => Vec<T::AccountId>;360361        /// Balance owner per collection map362        pub Balance get(fn balance_count): double_map hasher(blake2_128_concat) u64, hasher(blake2_128_concat) T::AccountId => u64;363364        /// second parameter: item id + owner account id365        pub ApprovedList get(fn approved): double_map hasher(blake2_128_concat) u64, hasher(blake2_128_concat) (u64, T::AccountId) => Vec<ApprovePermissions<T::AccountId>>;366367        /// Item collections368        pub NftItemList get(fn nft_item_id) config(): double_map hasher(blake2_128_concat) u64, hasher(blake2_128_concat) u64 => NftItemType<T::AccountId>;369        pub FungibleItemList get(fn fungible_item_id) config(): double_map hasher(blake2_128_concat) u64, hasher(blake2_128_concat) u64 => FungibleItemType<T::AccountId>;370        pub ReFungibleItemList get(fn refungible_item_id) config(): double_map hasher(blake2_128_concat) u64, hasher(blake2_128_concat) u64 => ReFungibleItemType<T::AccountId>;371372        /// Index list373        pub AddressTokens get(fn address_tokens): double_map hasher(blake2_128_concat) u64, hasher(blake2_128_concat) T::AccountId => Vec<u64>;374375        /// Tokens transfer baskets376        pub NftTransferBasket get(fn nft_transfer_basket): double_map hasher(blake2_128_concat) u64, hasher(blake2_128_concat) u64 => T::BlockNumber;377        pub FungibleTransferBasket get(fn fungible_transfer_basket): double_map hasher(blake2_128_concat) u64, hasher(blake2_128_concat) u64 => Vec<BasketItem<T::AccountId, T::BlockNumber>>;378        pub ReFungibleTransferBasket get(fn refungible_transfer_basket): double_map hasher(blake2_128_concat) u64, hasher(blake2_128_concat) u64 => T::BlockNumber;379380        // Contract Sponsorship and Ownership381        pub ContractOwner get(fn contract_owner): map hasher(twox_64_concat) T::AccountId => T::AccountId;382        pub ContractSelfSponsoring get(fn contract_self_sponsoring): map hasher(twox_64_concat) T::AccountId => bool;383        pub ContractSponsorBasket get(fn contract_sponsor_basket): map hasher(twox_64_concat) T::AccountId => T::BlockNumber;384        pub ContractSponsoringRateLimit get(fn contract_sponsoring_rate_limit): map hasher(twox_64_concat) T::AccountId => T::BlockNumber;385    }386    add_extra_genesis {387        build(|config: &GenesisConfig<T>| {388            // Modification of storage389            for (_num, _c) in &config.collection {390                <Module<T>>::init_collection(_c);391            }392393            for (_num, _q, _i) in &config.nft_item_id {394                <Module<T>>::init_nft_token(_i);395            }396397            for (_num, _q, _i) in &config.fungible_item_id {398                <Module<T>>::init_fungible_token(_i);399            }400401            for (_num, _q, _i) in &config.refungible_item_id {402                <Module<T>>::init_refungible_token(_i);403            }404        })405    }406}407408decl_event!(409    pub enum Event<T>410    where411        AccountId = <T as system::Trait>::AccountId,412    {413        /// New collection was created414        /// 415        /// # Arguments416        /// 417        /// * collection_id: Globally unique identifier of newly created collection.418        /// 419        /// * mode: [CollectionMode] converted into u8.420        /// 421        /// * account_id: Collection owner.422        Created(u64, u8, AccountId),423424        /// New item was created.425        /// 426        /// # Arguments427        /// 428        /// * collection_id: Id of the collection where item was created.429        /// 430        /// * item_id: Id of an item. Unique within the collection.431        ItemCreated(u64, u64),432433        /// Collection item was burned.434        /// 435        /// # Arguments436        /// 437        /// collection_id.438        /// 439        /// item_id: Identifier of burned NFT.440        ItemDestroyed(u64, u64),441    }442);443444decl_module! {445    pub struct Module<T: Trait> for enum Call where origin: T::Origin {446447        fn deposit_event() = default;448        type Error = Error<T>;449450        fn on_initialize(now: T::BlockNumber) -> Weight {451452            if ChainVersion::get() < 2453            {454                let value = NextCollectionID::get();455                CreatedCollectionCount::put(value);456                ChainVersion::put(2);457            }458459            0460        }461462        /// 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 and admin of the collection are set to the address that signed the transaction. Both addresses can be changed later.463        /// 464        /// # Permissions465        /// 466        /// * Anyone.467        /// 468        /// # Arguments469        /// 470        /// * collection_name: UTF-16 string with collection name (limit 64 characters), will be stored as zero-terminated.471        /// 472        /// * collection_description: UTF-16 string with collection description (limit 256 characters), will be stored as zero-terminated.473        /// 474        /// * token_prefix: UTF-8 string with token prefix.475        /// 476        /// * mode: [CollectionMode] collection type and type dependent data.477        // returns collection ID478        #[weight = T::WeightInfo::create_collection()]479        pub fn create_collection(origin,480                                 collection_name: Vec<u16>,481                                 collection_description: Vec<u16>,482                                 token_prefix: Vec<u8>,483                                 mode: CollectionMode) -> DispatchResult {484485            // Anyone can create a collection486            let who = ensure_signed(origin)?;487488            let decimal_points = match mode {489                CollectionMode::Fungible(points) => points,490                CollectionMode::ReFungible(points) => points,491                _ => 0492            };493494            // bound Total number of collections495            ensure!(CollectionCount::get() < ChainLimit::get().collection_numbers_limit, Error::<T>::TotalCollectionsLimitExceeded);496497            // check params498            ensure!(decimal_points <= 4, Error::<T>::CollectionDecimalPointLimitExceeded);499500            let mut name = collection_name.to_vec();501            name.push(0);502            ensure!(name.len() <= 64, Error::<T>::CollectionNameLimitExceeded);503504            let mut description = collection_description.to_vec();505            description.push(0);506            ensure!(name.len() <= 256, Error::<T>::CollectionDescriptionLimitExceeded);507508            let mut prefix = token_prefix.to_vec();509            prefix.push(0);510            ensure!(prefix.len() <= 16, Error::<T>::CollectionTokenPrefixLimitExceeded);511512            // Generate next collection ID513            let next_id = CreatedCollectionCount::get()514                .checked_add(1)515                .ok_or(Error::<T>::NumOverflow)?;516517            // bound counter518            let total = CollectionCount::get()519                .checked_add(1)520                .ok_or(Error::<T>::NumOverflow)?;521522            CreatedCollectionCount::put(next_id);523            CollectionCount::put(total);524525            // Create new collection526            let new_collection = CollectionType {527                owner: who.clone(),528                name: name,529                mode: mode.clone(),530                mint_mode: false,531                access: AccessMode::Normal,532                description: description,533                decimal_points: decimal_points,534                token_prefix: prefix,535                offchain_schema: Vec::new(),536                sponsor: T::AccountId::default(),537                unconfirmed_sponsor: T::AccountId::default(),538                variable_on_chain_schema: Vec::new(),539                const_on_chain_schema: Vec::new(),540            };541542            // Add new collection to map543            <Collection<T>>::insert(next_id, new_collection);544545            // call event546            Self::deposit_event(RawEvent::Created(next_id, mode.into(), who.clone()));547548            Ok(())549        }550551        /// **DANGEROUS**: Destroys collection and all NFTs within this collection. Users irrecoverably lose their assets and may lose real money.552        /// 553        /// # Permissions554        /// 555        /// * Collection Owner.556        /// 557        /// # Arguments558        /// 559        /// * collection_id: collection to destroy.560        #[weight = T::WeightInfo::destroy_collection()]561        pub fn destroy_collection(origin, collection_id: u64) -> DispatchResult {562563            let sender = ensure_signed(origin)?;564            Self::check_owner_permissions(collection_id, sender)?;565566            <AddressTokens<T>>::remove_prefix(collection_id);567            <ApprovedList<T>>::remove_prefix(collection_id);568            <Balance<T>>::remove_prefix(collection_id);569            <ItemListIndex>::remove(collection_id);570            <AdminList<T>>::remove(collection_id);571            <Collection<T>>::remove(collection_id);572            <WhiteList<T>>::remove(collection_id);573574            <NftItemList<T>>::remove_prefix(collection_id);575            <FungibleItemList<T>>::remove_prefix(collection_id);576            <ReFungibleItemList<T>>::remove_prefix(collection_id);577578            <NftTransferBasket<T>>::remove_prefix(collection_id);579            <FungibleTransferBasket<T>>::remove_prefix(collection_id);580            <ReFungibleTransferBasket<T>>::remove_prefix(collection_id);581582            if CollectionCount::get() > 0583            {584                // bound couter585                let total = CollectionCount::get()586                    .checked_sub(1)587                    .ok_or(Error::<T>::NumOverflow)?;588589                CollectionCount::put(total);590            }591592            Ok(())593        }594595        /// Add an address to white list.596        /// 597        /// # Permissions598        /// 599        /// * Collection Owner600        /// * Collection Admin601        /// 602        /// # Arguments603        /// 604        /// * collection_id.605        /// 606        /// * address.607        #[weight = T::WeightInfo::add_to_white_list()]608        pub fn add_to_white_list(origin, collection_id: u64, address: T::AccountId) -> DispatchResult{609610            let sender = ensure_signed(origin)?;611            Self::check_owner_or_admin_permissions(collection_id, sender)?;612613            let mut white_list_collection: Vec<T::AccountId>;614            if <WhiteList<T>>::contains_key(collection_id) {615                white_list_collection = <WhiteList<T>>::get(collection_id);616                if !white_list_collection.contains(&address.clone())617                {618                    white_list_collection.push(address.clone());619                }620            }621            else {622                white_list_collection = Vec::new();623                white_list_collection.push(address.clone());624            }625626            <WhiteList<T>>::insert(collection_id, white_list_collection);627            Ok(())628        }629630        /// Remove an address from white list.631        /// 632        /// # Permissions633        /// 634        /// * Collection Owner635        /// * Collection Admin636        /// 637        /// # Arguments638        /// 639        /// * collection_id.640        /// 641        /// * address.642        #[weight = T::WeightInfo::remove_from_white_list()]643        pub fn remove_from_white_list(origin, collection_id: u64, address: T::AccountId) -> DispatchResult{644645            let sender = ensure_signed(origin)?;646            Self::check_owner_or_admin_permissions(collection_id, sender)?;647648            if <WhiteList<T>>::contains_key(collection_id) {649                let mut white_list_collection = <WhiteList<T>>::get(collection_id);650                if white_list_collection.contains(&address.clone())651                {652                    white_list_collection.retain(|i| *i != address.clone());653                    <WhiteList<T>>::insert(collection_id, white_list_collection);654                }655            }656657            Ok(())658        }659660        /// Toggle between normal and white list access for the methods with access for `Anyone`.661        /// 662        /// # Permissions663        /// 664        /// * Collection Owner.665        /// 666        /// # Arguments667        /// 668        /// * collection_id.669        /// 670        /// * mode: [AccessMode]671        #[weight = T::WeightInfo::set_public_access_mode()]672        pub fn set_public_access_mode(origin, collection_id: u64, mode: AccessMode) -> DispatchResult673        {674            let sender = ensure_signed(origin)?;675676            Self::check_owner_permissions(collection_id, sender)?;677            let mut target_collection = <Collection<T>>::get(collection_id);678            target_collection.access = mode;679            <Collection<T>>::insert(collection_id, target_collection);680681            Ok(())682        }683684        /// Allows Anyone to create tokens if:685        /// * White List is enabled, and686        /// * Address is added to white list, and687        /// * This method was called with True parameter688        /// 689        /// # Permissions690        /// * Collection Owner691        ///692        /// # Arguments693        /// 694        /// * collection_id.695        /// 696        /// * mint_permission: Boolean parameter. If True, allows minting to Anyone with conditions above.697        #[weight = T::WeightInfo::set_mint_permission()]698        pub fn set_mint_permission(origin, collection_id: u64, mint_permission: bool) -> DispatchResult699        {700            let sender = ensure_signed(origin)?;701702            Self::check_owner_permissions(collection_id, sender)?;703            let mut target_collection = <Collection<T>>::get(collection_id);704            target_collection.mint_mode = mint_permission;705            <Collection<T>>::insert(collection_id, target_collection);706707            Ok(())708        }709710        /// Change the owner of the collection.711        /// 712        /// # Permissions713        /// 714        /// * Collection Owner.715        /// 716        /// # Arguments717        /// 718        /// * collection_id.719        /// 720        /// * new_owner.721        #[weight = T::WeightInfo::change_collection_owner()]722        pub fn change_collection_owner(origin, collection_id: u64, new_owner: T::AccountId) -> DispatchResult {723724            let sender = ensure_signed(origin)?;725            Self::check_owner_permissions(collection_id, sender)?;726            let mut target_collection = <Collection<T>>::get(collection_id);727            target_collection.owner = new_owner;728            <Collection<T>>::insert(collection_id, target_collection);729730            Ok(())731        }732733        /// Adds an admin of the Collection.734        /// 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. 735        /// 736        /// # Permissions737        /// 738        /// * Collection Owner.739        /// * Collection Admin.740        /// 741        /// # Arguments742        /// 743        /// * collection_id: ID of the Collection to add admin for.744        /// 745        /// * new_admin_id: Address of new admin to add.746        #[weight = T::WeightInfo::add_collection_admin()]747        pub fn add_collection_admin(origin, collection_id: u64, new_admin_id: T::AccountId) -> DispatchResult {748749            let sender = ensure_signed(origin)?;750            Self::check_owner_or_admin_permissions(collection_id, sender)?;751            let mut admin_arr: Vec<T::AccountId> = Vec::new();752753            if <AdminList<T>>::contains_key(collection_id)754            {755                admin_arr = <AdminList<T>>::get(collection_id);756                ensure!(!admin_arr.contains(&new_admin_id), Error::<T>::AlreadyAdmin);757            }758759            // Number of collection admins760            ensure!((admin_arr.len() as u64) < ChainLimit::get().collections_admins_limit, Error::<T>::CollectionAdminsLimitExceeded);761762            admin_arr.push(new_admin_id);763            <AdminList<T>>::insert(collection_id, admin_arr);764765            Ok(())766        }767768        /// 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.769        ///770        /// # Permissions771        /// 772        /// * Collection Owner.773        /// * Collection Admin.774        /// 775        /// # Arguments776        /// 777        /// * collection_id: ID of the Collection to remove admin for.778        /// 779        /// * account_id: Address of admin to remove.780        #[weight = T::WeightInfo::remove_collection_admin()]781        pub fn remove_collection_admin(origin, collection_id: u64, account_id: T::AccountId) -> DispatchResult {782783            let sender = ensure_signed(origin)?;784            Self::check_owner_or_admin_permissions(collection_id, sender)?;785786            if <AdminList<T>>::contains_key(collection_id)787            {788                let mut admin_arr = <AdminList<T>>::get(collection_id);789                admin_arr.retain(|i| *i != account_id);790                <AdminList<T>>::insert(collection_id, admin_arr);791            }792793            Ok(())794        }795796        /// # Permissions797        /// 798        /// * Collection Owner799        /// 800        /// # Arguments801        /// 802        /// * collection_id.803        /// 804        /// * new_sponsor.805        #[weight = T::WeightInfo::set_collection_sponsor()]806        pub fn set_collection_sponsor(origin, collection_id: u64, new_sponsor: T::AccountId) -> DispatchResult {807808            let sender = ensure_signed(origin)?;809            ensure!(<Collection<T>>::contains_key(collection_id), Error::<T>::CollectionNotFound);810811            let mut target_collection = <Collection<T>>::get(collection_id);812            ensure!(sender == target_collection.owner, Error::<T>::NoPermission);813814            target_collection.unconfirmed_sponsor = new_sponsor;815            <Collection<T>>::insert(collection_id, target_collection);816817            Ok(())818        }819820        /// # Permissions821        /// 822        /// * Sponsor.823        /// 824        /// # Arguments825        /// 826        /// * collection_id.827        #[weight = T::WeightInfo::confirm_sponsorship()]828        pub fn confirm_sponsorship(origin, collection_id: u64) -> DispatchResult {829830            let sender = ensure_signed(origin)?;831            ensure!(<Collection<T>>::contains_key(collection_id), Error::<T>::CollectionNotFound);832833            let mut target_collection = <Collection<T>>::get(collection_id);834            ensure!(sender == target_collection.unconfirmed_sponsor, Error::<T>::ConfirmUnsetSponsorFail);835836            target_collection.sponsor = target_collection.unconfirmed_sponsor;837            target_collection.unconfirmed_sponsor = T::AccountId::default();838            <Collection<T>>::insert(collection_id, target_collection);839840            Ok(())841        }842843        /// Switch back to pay-per-own-transaction model.844        ///845        /// # Permissions846        ///847        /// * Collection owner.848        /// 849        /// # Arguments850        /// 851        /// * collection_id.852        #[weight = T::WeightInfo::remove_collection_sponsor()]853        pub fn remove_collection_sponsor(origin, collection_id: u64) -> DispatchResult {854855            let sender = ensure_signed(origin)?;856            ensure!(<Collection<T>>::contains_key(collection_id), Error::<T>::CollectionNotFound);857858            let mut target_collection = <Collection<T>>::get(collection_id);859            ensure!(sender == target_collection.owner, Error::<T>::NoPermission);860861            target_collection.sponsor = T::AccountId::default();862            <Collection<T>>::insert(collection_id, target_collection);863864            Ok(())865        }866867        /// This method creates a concrete instance of NFT Collection created with CreateCollection method.868        /// 869        /// # Permissions870        /// 871        /// * Collection Owner.872        /// * Collection Admin.873        /// * Anyone if874        ///     * White List is enabled, and875        ///     * Address is added to white list, and876        ///     * MintPermission is enabled (see SetMintPermission method)877        /// 878        /// # Arguments879        /// 880        /// * collection_id: ID of the collection.881        /// 882        /// * owner: Address, initial owner of the NFT.883        ///884        /// * data: Token data to store on chain.885        // #[weight =886        // (130_000_000 as Weight)887        // .saturating_add((2135 as Weight).saturating_mul((properties.len() as u64) as Weight))888        // .saturating_add(RocksDbWeight::get().reads(10 as Weight))889        // .saturating_add(RocksDbWeight::get().writes(8 as Weight))]890891        #[weight = T::WeightInfo::create_item(data.len())]892        pub fn create_item(origin, collection_id: u64, owner: T::AccountId, data: CreateItemData) -> DispatchResult {893894            let sender = ensure_signed(origin)?;895896            Self::collection_exists(collection_id)?;897898            let target_collection = <Collection<T>>::get(collection_id);899900            Self::can_create_items_in_collection(collection_id, &target_collection, &sender, &owner)?;901            Self::validate_create_item_args(&target_collection, &data)?;902            Self::create_item_no_validation(collection_id, &target_collection, owner, data)?;903904            Ok(())905        }906907        /// This method creates multiple instances of NFT Collection created with CreateCollection method.908        /// 909        /// # Permissions910        /// 911        /// * Collection Owner.912        /// * Collection Admin.913        /// * Anyone if914        ///     * White List is enabled, and915        ///     * Address is added to white list, and916        ///     * MintPermission is enabled (see SetMintPermission method)917        /// 918        /// # Arguments919        /// 920        /// * collection_id: ID of the collection.921        /// 922        /// * itemsData: Array items properties. Each property is an array of bytes itself, see [create_item].923        /// 924        /// * owner: Address, initial owner of the NFT.925        #[weight = T::WeightInfo::create_item(items_data.into_iter()926                               .map(|data| { data.len() })927                               .sum())]928        pub fn create_multiple_items(origin, collection_id: u64, owner: T::AccountId, items_data: Vec<CreateItemData>) -> DispatchResult {929930            ensure!(items_data.len() > 0, Error::<T>::EmptyArgument);931            let sender = ensure_signed(origin)?;932933            Self::collection_exists(collection_id)?;934            let target_collection = <Collection<T>>::get(collection_id);935936            Self::can_create_items_in_collection(collection_id, &target_collection, &sender, &owner)?;937938            for data in &items_data {939                Self::validate_create_item_args(&target_collection, data)?;940            }941            for data in &items_data {942                Self::create_item_no_validation(collection_id, &target_collection, owner.clone(), data.clone())?;943            }944945            Ok(())946        }947948        /// Destroys a concrete instance of NFT.949        /// 950        /// # Permissions951        /// 952        /// * Collection Owner.953        /// * Collection Admin.954        /// * Current NFT Owner.955        /// 956        /// # Arguments957        /// 958        /// * collection_id: ID of the collection.959        /// 960        /// * item_id: ID of NFT to burn.961        #[weight = T::WeightInfo::burn_item()]962        pub fn burn_item(origin, collection_id: u64, item_id: u64) -> DispatchResult {963964            let sender = ensure_signed(origin)?;965            Self::collection_exists(collection_id)?;966967            // Transfer permissions check968            let target_collection = <Collection<T>>::get(collection_id);969            ensure!(Self::is_item_owner(sender.clone(), collection_id, item_id) ||970                Self::is_owner_or_admin_permissions(collection_id, sender.clone()),971                Error::<T>::NoPermission);972973            if target_collection.access == AccessMode::WhiteList {974                Self::check_white_list(collection_id, &sender)?;975            }976977            match target_collection.mode978            {979                CollectionMode::NFT => Self::burn_nft_item(collection_id, item_id)?,980                CollectionMode::Fungible(_)  => Self::burn_fungible_item(collection_id, item_id)?,981                CollectionMode::ReFungible(_)  => Self::burn_refungible_item(collection_id, item_id, sender.clone())?,982                _ => ()983            };984985            // call event986            Self::deposit_event(RawEvent::ItemDestroyed(collection_id, item_id));987988            Ok(())989        }990991        /// Change ownership of the token.992        /// 993        /// # Permissions994        /// 995        /// * Collection Owner996        /// * Collection Admin997        /// * Current NFT owner998        ///999        /// # Arguments1000        /// 1001        /// * recipient: Address of token recipient.1002        /// 1003        /// * collection_id.1004        /// 1005        /// * item_id: ID of the item1006        ///     * Non-Fungible Mode: Required.1007        ///     * Fungible Mode: Ignored.1008        ///     * Re-Fungible Mode: Required.1009        /// 1010        /// * value: Amount to transfer.1011        ///     * Non-Fungible Mode: Ignored1012        ///     * Fungible Mode: Must specify transferred amount1013        ///     * Re-Fungible Mode: Must specify transferred portion (between 0 and 1)1014        #[weight = T::WeightInfo::transfer()]1015        pub fn transfer(origin, recipient: T::AccountId, collection_id: u64, item_id: u64, value: u64) -> DispatchResult {10161017            let sender = ensure_signed(origin)?;10181019            // Transfer permissions check1020            let target_collection = <Collection<T>>::get(collection_id);1021            ensure!(Self::is_item_owner(sender.clone(), collection_id, item_id) ||1022                Self::is_owner_or_admin_permissions(collection_id, sender.clone()),1023                Error::<T>::NoPermission);10241025            if target_collection.access == AccessMode::WhiteList {1026                Self::check_white_list(collection_id, &sender)?;1027                Self::check_white_list(collection_id, &recipient)?;1028            }10291030            match target_collection.mode1031            {1032                CollectionMode::NFT => Self::transfer_nft(collection_id, item_id, sender.clone(), recipient)?,1033                CollectionMode::Fungible(_)  => Self::transfer_fungible(collection_id, item_id, value, sender.clone(), recipient)?,1034                CollectionMode::ReFungible(_)  => Self::transfer_refungible(collection_id, item_id, value, sender.clone(), recipient)?,1035                _ => ()1036            };10371038            Ok(())1039        }10401041        /// Set, change, or remove approved address to transfer the ownership of the NFT.1042        /// 1043        /// # Permissions1044        /// 1045        /// * Collection Owner1046        /// * Collection Admin1047        /// * Current NFT owner1048        /// 1049        /// # Arguments1050        /// 1051        /// * approved: Address that is approved to transfer this NFT or zero (if needed to remove approval).1052        /// 1053        /// * collection_id.1054        /// 1055        /// * item_id: ID of the item.1056        #[weight = T::WeightInfo::approve()]1057        pub fn approve(origin, approved: T::AccountId, collection_id: u64, item_id: u64) -> DispatchResult {10581059            let sender = ensure_signed(origin)?;10601061            // Transfer permissions check1062            let target_collection = <Collection<T>>::get(collection_id);1063            ensure!(Self::is_item_owner(sender.clone(), collection_id, item_id) ||1064                Self::is_owner_or_admin_permissions(collection_id, sender.clone()),1065                Error::<T>::NoPermission);10661067            if target_collection.access == AccessMode::WhiteList {1068                Self::check_white_list(collection_id, &sender)?;1069                Self::check_white_list(collection_id, &approved)?;1070            }10711072            // amount param stub1073            let amount = 100000000;10741075            let list_exists = <ApprovedList<T>>::contains_key(collection_id, (item_id, sender.clone()));1076            if list_exists {10771078                let mut list = <ApprovedList<T>>::get(collection_id, (item_id, sender.clone()));1079                let item_contains = list.iter().any(|i| i.approved == approved);10801081                if !item_contains {1082                    list.push(ApprovePermissions { approved: approved.clone(), amount: amount });1083                    <ApprovedList<T>>::insert(collection_id, (item_id, sender.clone()), list);1084                }1085            } else {10861087                let mut list = Vec::new();1088                list.push(ApprovePermissions { approved: approved.clone(), amount: amount });1089                <ApprovedList<T>>::insert(collection_id, (item_id, sender.clone()), list);1090            }10911092            Ok(())1093        }1094        1095        /// 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.1096        /// 1097        /// # Permissions1098        /// * Collection Owner1099        /// * Collection Admin1100        /// * Current NFT owner1101        /// * Address approved by current NFT owner1102        /// 1103        /// # Arguments1104        /// 1105        /// * from: Address that owns token.1106        /// 1107        /// * recipient: Address of token recipient.1108        /// 1109        /// * collection_id.1110        /// 1111        /// * item_id: ID of the item.1112        /// 1113        /// * value: Amount to transfer.1114        #[weight = T::WeightInfo::transfer_from()]1115        pub fn transfer_from(origin, from: T::AccountId, recipient: T::AccountId, collection_id: u64, item_id: u64, value: u64 ) -> DispatchResult {11161117            let sender = ensure_signed(origin)?;1118            let mut appoved_transfer = false;11191120            // Check approve1121            if <ApprovedList<T>>::contains_key(collection_id, (item_id, from.clone())) {1122                let list_itm = <ApprovedList<T>>::get(collection_id, (item_id, from.clone()));1123                let opt_item = list_itm.iter().find(|i| i.approved == sender.clone());1124                if opt_item.is_some()1125                {1126                    appoved_transfer = true;1127                    ensure!(opt_item.unwrap().amount >= value, Error::<T>::TokenValueNotEnough);1128                }1129            }11301131            // Transfer permissions check1132            let target_collection = <Collection<T>>::get(collection_id);1133                ensure!(appoved_transfer || Self::is_owner_or_admin_permissions(collection_id, sender.clone()),1134                Error::<T>::NoPermission);11351136            if target_collection.access == AccessMode::WhiteList {1137                Self::check_white_list(collection_id, &sender)?;1138                Self::check_white_list(collection_id, &recipient)?;1139            }11401141            // remove approve1142            let approve_list: Vec<ApprovePermissions<T::AccountId>> = <ApprovedList<T>>::get(collection_id, (item_id, from.clone()))1143                .into_iter().filter(|i| i.approved != sender.clone()).collect();1144            <ApprovedList<T>>::insert(collection_id, (item_id, from.clone()), approve_list);114511461147            match target_collection.mode1148            {1149                CollectionMode::NFT => Self::transfer_nft(collection_id, item_id, from, recipient)?,1150                CollectionMode::Fungible(_)  => Self::transfer_fungible(collection_id, item_id, value, from.clone(), recipient)?,1151                CollectionMode::ReFungible(_)  => Self::transfer_refungible(collection_id, item_id, value, from.clone(), recipient)?,1152                _ => ()1153            };11541155            Ok(())1156        }11571158        ///1159        #[weight = 0]1160        pub fn safe_transfer_from(origin, collection_id: u64, item_id: u64, new_owner: T::AccountId) -> DispatchResult {11611162            // let no_perm_mes = "You do not have permissions to modify this collection";1163            // ensure!(<ApprovedList<T>>::contains_key((collection_id, item_id)), no_perm_mes);1164            // let list_itm = <ApprovedList<T>>::get((collection_id, item_id));1165            // ensure!(list_itm.contains(&new_owner.clone()), no_perm_mes);11661167            // // on_nft_received  call11681169            // Self::transfer(origin, collection_id, item_id, new_owner)?;11701171            Ok(())1172        }11731174        /// Set off-chain data schema.1175        /// 1176        /// # Permissions1177        /// 1178        /// * Collection Owner1179        /// * Collection Admin1180        /// 1181        /// # Arguments1182        /// 1183        /// * collection_id.1184        /// 1185        /// * schema: String representing the offchain data schema.1186        #[weight = T::WeightInfo::set_variable_meta_data()]1187        pub fn set_variable_meta_data (1188            origin,1189            collection_id: u64,1190            item_id: u64,1191            data: Vec<u8>1192        ) -> DispatchResult {1193            let sender = ensure_signed(origin)?;1194            1195            Self::collection_exists(collection_id)?;1196            1197            ensure!(ChainLimit::get().custom_data_limit >= data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);11981199            // Modify permissions check1200            let target_collection = <Collection<T>>::get(collection_id);1201            ensure!(Self::is_item_owner(sender.clone(), collection_id, item_id) ||1202                Self::is_owner_or_admin_permissions(collection_id, sender.clone()),1203                Error::<T>::NoPermission);12041205            Self::item_exists(collection_id, item_id, &target_collection.mode)?;12061207            match target_collection.mode1208            {1209                CollectionMode::NFT => Self::set_nft_variable_data(collection_id, item_id, data)?,1210                CollectionMode::ReFungible(_)  => Self::set_re_fungible_variable_data(collection_id, item_id, data)?,1211                CollectionMode::Fungible(_) => fail!(Error::<T>::CantStoreMetadataInFungibleTokens),1212                _ => fail!(Error::<T>::UnexpectedCollectionType)1213            };12141215            Ok(())1216        }1217        12181219        /// Set off-chain data schema.1220        /// 1221        /// # Permissions1222        /// 1223        /// * Collection Owner1224        /// * Collection Admin1225        /// 1226        /// # Arguments1227        /// 1228        /// * collection_id.1229        /// 1230        /// * schema: String representing the offchain data schema.1231        #[weight = T::WeightInfo::set_offchain_schema()]1232        pub fn set_offchain_schema(1233            origin,1234            collection_id: u64,1235            schema: Vec<u8>1236        ) -> DispatchResult {1237            let sender = ensure_signed(origin)?;1238            Self::check_owner_or_admin_permissions(collection_id, sender.clone())?;12391240            let mut target_collection = <Collection<T>>::get(collection_id);1241            target_collection.offchain_schema = schema;1242            <Collection<T>>::insert(collection_id, target_collection);12431244            Ok(())1245        }12461247        /// Set const on-chain data schema.1248        /// 1249        /// # Permissions1250        /// 1251        /// * Collection Owner1252        /// * Collection Admin1253        /// 1254        /// # Arguments1255        /// 1256        /// * collection_id.1257        /// 1258        /// * schema: String representing the const on-chain data schema.1259        #[weight = T::WeightInfo::set_const_on_chain_schema()]1260        pub fn set_const_on_chain_schema (1261            origin,1262            collection_id: u64,1263            schema: Vec<u8>1264        ) -> DispatchResult {1265            let sender = ensure_signed(origin)?;1266            Self::check_owner_or_admin_permissions(collection_id, sender.clone())?;12671268            let mut target_collection = <Collection<T>>::get(collection_id);1269            target_collection.const_on_chain_schema = schema;1270            <Collection<T>>::insert(collection_id, target_collection);12711272            Ok(())1273        }12741275        /// Set variable on-chain data schema.1276        /// 1277        /// # Permissions1278        /// 1279        /// * Collection Owner1280        /// * Collection Admin1281        /// 1282        /// # Arguments1283        /// 1284        /// * collection_id.1285        /// 1286        /// * schema: String representing the variable on-chain data schema.1287        #[weight = T::WeightInfo::set_const_on_chain_schema()]1288        pub fn set_variable_on_chain_schema (1289            origin,1290            collection_id: u64,1291            schema: Vec<u8>1292        ) -> DispatchResult {1293            let sender = ensure_signed(origin)?;1294            Self::check_owner_or_admin_permissions(collection_id, sender.clone())?;12951296            let mut target_collection = <Collection<T>>::get(collection_id);1297            target_collection.variable_on_chain_schema = schema;1298            <Collection<T>>::insert(collection_id, target_collection);12991300            Ok(())1301        }13021303        // Sudo permissions function1304        #[weight = 0]1305        pub fn set_chain_limits(1306            origin,1307            limits: ChainLimits1308        ) -> DispatchResult {1309            ensure_root(origin)?;1310            <ChainLimit>::put(limits);1311            Ok(())1312        }13131314        /// Enable smart contract self-sponsoring.1315        /// 1316        /// # Permissions1317        /// 1318        /// * Contract Owner1319        /// 1320        /// # Arguments1321        /// 1322        /// * contract address1323        /// * enable flag1324        /// 1325        #[weight = T::WeightInfo::enable_contract_sponsoring()]1326        pub fn enable_contract_sponsoring(1327            origin,1328            contract_address: T::AccountId,1329            enable: bool1330        ) -> DispatchResult {13311332            let sender = ensure_signed(origin)?;13331334            #[cfg(feature = "runtime-benchmarks")]1335            <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());13361337            let mut is_owner = false;1338            if <ContractOwner<T>>::contains_key(contract_address.clone()) {1339                let owner = <ContractOwner<T>>::get(&contract_address);1340                is_owner = sender == owner;1341            }1342            ensure!(is_owner, Error::<T>::NoPermission);13431344            <ContractSelfSponsoring<T>>::insert(contract_address, enable);1345            Ok(())1346        }13471348        /// Set the rate limit for contract sponsoring to specified number of blocks.1349        /// 1350        /// If not set (has the default value of 0 blocks), the sponsoring will be disabled. 1351        /// If set to the number B (for blocks), the transactions will be sponsored with a rate 1352        /// limit of B, i.e. fees for every transaction sent to this smart contract will be paid 1353        /// from contract endowment if there are at least B blocks between such transactions. 1354        /// Nonetheless, if transactions are sent more frequently, the fees are paid by the sender.1355        /// 1356        /// # Permissions1357        /// 1358        /// * Contract Owner1359        /// 1360        /// # Arguments1361        /// 1362        /// -`contract_address`: Address of the contract to sponsor1363        /// -`rate_limit`: Number of blocks to wait until the next sponsored transaction is allowed1364        /// 1365        #[weight = 0]1366        pub fn set_contract_sponsoring_rate_limit(1367            origin,1368            contract_address: T::AccountId,1369            rate_limit: T::BlockNumber1370        ) -> DispatchResult {1371            let sender = ensure_signed(origin)?;1372            let mut is_owner = false;1373            if <ContractOwner<T>>::contains_key(contract_address.clone()) {1374                let owner = <ContractOwner<T>>::get(&contract_address);1375                is_owner = sender == owner;1376            }1377            ensure!(is_owner, Error::<T>::NoPermission);13781379            <ContractSponsoringRateLimit<T>>::insert(contract_address, rate_limit);1380            Ok(())1381        }13821383        // #[cfg(feature = "runtime-benchmarks")]1384        // #[weight = 0]1385        // pub fn add_contract_sponsoring_debug(1386        //     origin,1387        //     contract_address: T::AccountId, 1388        //     owner: T::AccountId) -> DispatchResult {1389        //     let sender = ensure_signed(origin)?;1390        //     <ContractOwner<T>>::insert(contract_address.clone(), owner);1391        //     Ok(())1392        // }1393    1394    }1395}13961397impl<T: Trait> Module<T> {13981399    fn can_create_items_in_collection(collection_id: u64, collection: &CollectionType<T::AccountId>, sender: &T::AccountId, owner: &T::AccountId) -> DispatchResult {14001401        if !Self::is_owner_or_admin_permissions(collection_id, sender.clone()) {1402            ensure!(collection.mint_mode == true, Error::<T>::PublicMintingNotAllowed);1403            Self::check_white_list(collection_id, owner)?;1404            Self::check_white_list(collection_id, sender)?;1405        }14061407        Ok(())1408    }14091410    fn validate_create_item_args(target_collection: &CollectionType<T::AccountId>, data: &CreateItemData) -> DispatchResult {1411        match target_collection.mode1412        {1413            CollectionMode::NFT => {1414                if let CreateItemData::NFT(data) = data {1415                    // check sizes1416                    ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, Error::<T>::TokenConstDataLimitExceeded);1417                    ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);1418                } else {1419                    fail!(Error::<T>::NotNftDataUsedToMintNftCollectionToken);1420                }1421            },1422            CollectionMode::Fungible(_) => {1423                if let CreateItemData::Fungible(_) = data {1424                } else {1425                    fail!(Error::<T>::NotFungibleDataUsedToMintFungibleCollectionToken);1426                }1427            },1428            CollectionMode::ReFungible(_) => {1429                if let CreateItemData::ReFungible(data) = data {14301431                    // check sizes1432                    ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, Error::<T>::TokenConstDataLimitExceeded);1433                    ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);1434                } else {1435                    fail!(Error::<T>::NotReFungibleDataUsedToMintReFungibleCollectionToken);1436                }1437            },1438            _ => { fail!(Error::<T>::UnexpectedCollectionType); }1439        };14401441        Ok(())1442    }14431444    fn create_item_no_validation(collection_id: u64, collection: &CollectionType<T::AccountId>, owner: T::AccountId, data: CreateItemData) -> DispatchResult {1445        match data1446        {1447            CreateItemData::NFT(data) => {1448                let item = NftItemType {1449                    collection: collection_id,1450                    owner,1451                    const_data: data.const_data,1452                    variable_data: data.variable_data1453                };14541455                Self::add_nft_item(item)?;1456            },1457            CreateItemData::Fungible(_) => {1458                let item = FungibleItemType {1459                    collection: collection_id,1460                    owner,1461                    value: (10 as u128).pow(collection.decimal_points)1462                };14631464                Self::add_fungible_item(item)?;1465            },1466            CreateItemData::ReFungible(data) => {1467                let mut owner_list = Vec::new();1468                let value = (10 as u128).pow(collection.decimal_points);1469                owner_list.push(Ownership {owner: owner.clone(), fraction: value});14701471                let item = ReFungibleItemType {1472                    collection: collection_id,1473                    owner: owner_list,1474                    const_data: data.const_data,1475                    variable_data: data.variable_data1476                };14771478                Self::add_refungible_item(item)?;1479            }1480        };148114821483        // call event1484        Self::deposit_event(RawEvent::ItemCreated(collection_id, <ItemListIndex>::get(collection_id)));14851486        Ok(())1487    }14881489    fn add_fungible_item(item: FungibleItemType<T::AccountId>) -> DispatchResult {1490        let current_index = <ItemListIndex>::get(item.collection)1491            .checked_add(1)1492            .ok_or(Error::<T>::NumOverflow)?;1493        let itemcopy = item.clone();1494        let owner = item.owner.clone();1495        let value = item.value as u64;14961497        Self::add_token_index(item.collection, current_index, owner.clone())?;14981499        <ItemListIndex>::insert(item.collection, current_index);1500        <FungibleItemList<T>>::insert(item.collection, current_index, itemcopy);15011502        // Add current block1503        let v: Vec<BasketItem<T::AccountId, T::BlockNumber>> = Vec::new();1504        <FungibleTransferBasket<T>>::insert(item.collection, current_index, v);1505        1506        // Update balance1507        let new_balance = <Balance<T>>::get(item.collection, owner.clone())1508            .checked_add(value)1509            .ok_or(Error::<T>::NumOverflow)?;1510        <Balance<T>>::insert(item.collection, owner.clone(), new_balance);15111512        Ok(())1513    }15141515    fn add_refungible_item(item: ReFungibleItemType<T::AccountId>) -> DispatchResult {1516        let current_index = <ItemListIndex>::get(item.collection)1517            .checked_add(1)1518            .ok_or(Error::<T>::NumOverflow)?;1519        let itemcopy = item.clone();15201521        let value = item.owner.first().unwrap().fraction as u64;1522        let owner = item.owner.first().unwrap().owner.clone();15231524        Self::add_token_index(item.collection, current_index, owner.clone())?;15251526        <ItemListIndex>::insert(item.collection, current_index);1527        <ReFungibleItemList<T>>::insert(item.collection, current_index, itemcopy);15281529        // Add current block1530        let block_number: T::BlockNumber = 0.into();1531        <ReFungibleTransferBasket<T>>::insert(item.collection, current_index, block_number);15321533        // Update balance1534        let new_balance = <Balance<T>>::get(item.collection, owner.clone())1535            .checked_add(value)1536            .ok_or(Error::<T>::NumOverflow)?;1537        <Balance<T>>::insert(item.collection, owner.clone(), new_balance);15381539        Ok(())1540    }15411542    fn add_nft_item(item: NftItemType<T::AccountId>) -> DispatchResult {1543        let current_index = <ItemListIndex>::get(item.collection)1544            .checked_add(1)1545            .ok_or(Error::<T>::NumOverflow)?;15461547        let item_owner = item.owner.clone();1548        let collection_id = item.collection.clone();1549        Self::add_token_index(collection_id, current_index, item.owner.clone())?;15501551        <ItemListIndex>::insert(collection_id, current_index);1552        <NftItemList<T>>::insert(collection_id, current_index, item);15531554        // Add current block1555        let block_number: T::BlockNumber = 0.into();1556        <NftTransferBasket<T>>::insert(collection_id, current_index, block_number);15571558        // Update balance1559        let new_balance = <Balance<T>>::get(collection_id, item_owner.clone())1560            .checked_add(1)1561            .ok_or(Error::<T>::NumOverflow)?;1562        <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);15631564        Ok(())1565    }15661567    fn burn_refungible_item(1568        collection_id: u64,1569        item_id: u64,1570        owner: T::AccountId,1571    ) -> DispatchResult {1572        ensure!(1573            <ReFungibleItemList<T>>::contains_key(collection_id, item_id),1574            Error::<T>::TokenNotFound1575        );1576        let collection = <ReFungibleItemList<T>>::get(collection_id, item_id);1577        let item = collection1578            .owner1579            .iter()1580            .filter(|&i| i.owner == owner)1581            .next()1582            .unwrap();1583        Self::remove_token_index(collection_id, item_id, owner.clone())?;15841585        // remove approve list1586        <ApprovedList<T>>::remove(collection_id, (item_id, owner.clone()));15871588        // update balance1589        let new_balance = <Balance<T>>::get(collection_id, item.owner.clone())1590            .checked_sub(item.fraction as u64)1591            .ok_or(Error::<T>::NumOverflow)?;1592        <Balance<T>>::insert(collection_id, item.owner.clone(), new_balance);15931594        <ReFungibleItemList<T>>::remove(collection_id, item_id);15951596        Ok(())1597    }15981599    fn burn_nft_item(collection_id: u64, item_id: u64) -> DispatchResult {1600        ensure!(1601            <NftItemList<T>>::contains_key(collection_id, item_id),1602            Error::<T>::TokenNotFound1603        );1604        let item = <NftItemList<T>>::get(collection_id, item_id);1605        Self::remove_token_index(collection_id, item_id, item.owner.clone())?;16061607        // remove approve list1608        <ApprovedList<T>>::remove(collection_id, (item_id, item.owner.clone()));16091610        // update balance1611        let new_balance = <Balance<T>>::get(collection_id, item.owner.clone())1612            .checked_sub(1)1613            .ok_or(Error::<T>::NumOverflow)?;1614        <Balance<T>>::insert(collection_id, item.owner.clone(), new_balance);1615        <NftItemList<T>>::remove(collection_id, item_id);16161617        Ok(())1618    }16191620    fn burn_fungible_item(collection_id: u64, item_id: u64) -> DispatchResult {1621        ensure!(1622            <FungibleItemList<T>>::contains_key(collection_id, item_id),1623            Error::<T>::TokenNotFound1624        );1625        let item = <FungibleItemList<T>>::get(collection_id, item_id);1626        Self::remove_token_index(collection_id, item_id, item.owner.clone())?;16271628        // remove approve list1629        <ApprovedList<T>>::remove(collection_id, (item_id, item.owner.clone()));16301631        // update balance1632        let new_balance = <Balance<T>>::get(collection_id, item.owner.clone())1633            .checked_sub(item.value as u64)1634            .ok_or(Error::<T>::NumOverflow)?;1635        <Balance<T>>::insert(collection_id, item.owner.clone(), new_balance);16361637        <FungibleItemList<T>>::remove(collection_id, item_id);16381639        Ok(())1640    }16411642    fn collection_exists(collection_id: u64) -> DispatchResult {1643        ensure!(1644            <Collection<T>>::contains_key(collection_id),1645            Error::<T>::CollectionNotFound1646        );1647        Ok(())1648    }16491650    fn check_owner_permissions(collection_id: u64, subject: T::AccountId) -> DispatchResult {1651        Self::collection_exists(collection_id)?;16521653        let target_collection = <Collection<T>>::get(collection_id);1654        ensure!(1655            subject == target_collection.owner,1656            Error::<T>::NoPermission1657        );16581659        Ok(())1660    }16611662    fn is_owner_or_admin_permissions(collection_id: u64, subject: T::AccountId) -> bool {1663        let target_collection = <Collection<T>>::get(collection_id);1664        let mut result: bool = subject == target_collection.owner;1665        let exists = <AdminList<T>>::contains_key(collection_id);16661667        if !result & exists {1668            if <AdminList<T>>::get(collection_id).contains(&subject) {1669                result = true1670            }1671        }16721673        result1674    }16751676    fn check_owner_or_admin_permissions(1677        collection_id: u64,1678        subject: T::AccountId,1679    ) -> DispatchResult {1680        Self::collection_exists(collection_id)?;1681        let result = Self::is_owner_or_admin_permissions(collection_id, subject.clone());16821683        ensure!(1684            result,1685            Error::<T>::NoPermission1686        );1687        Ok(())1688    }16891690    fn is_item_owner(subject: T::AccountId, collection_id: u64, item_id: u64) -> bool {1691        let target_collection = <Collection<T>>::get(collection_id);16921693        match target_collection.mode {1694            CollectionMode::NFT => {1695                <NftItemList<T>>::get(collection_id, item_id).owner == subject1696            }1697            CollectionMode::Fungible(_) => {1698                <FungibleItemList<T>>::get(collection_id, item_id).owner == subject1699            }1700            CollectionMode::ReFungible(_) => {1701                <ReFungibleItemList<T>>::get(collection_id, item_id)1702                    .owner1703                    .iter()1704                    .any(|i| i.owner == subject)1705            }1706            CollectionMode::Invalid => false,1707        }1708    }17091710    fn check_white_list(collection_id: u64, address: &T::AccountId) -> DispatchResult {1711        let mes = Error::<T>::AddresNotInWhiteList;1712        ensure!(<WhiteList<T>>::contains_key(collection_id), mes);1713        let wl = <WhiteList<T>>::get(collection_id);1714        ensure!(wl.contains(address), mes);17151716        Ok(())1717    }17181719    fn transfer_fungible(1720        collection_id: u64,1721        item_id: u64,1722        value: u64,1723        owner: T::AccountId,1724        new_owner: T::AccountId,1725    ) -> DispatchResult {1726        ensure!(1727            <FungibleItemList<T>>::contains_key(collection_id, item_id),1728            Error::<T>::TokenNotFound1729        );17301731        let full_item = <FungibleItemList<T>>::get(collection_id, item_id);1732        let amount = full_item.value;17331734        ensure!(amount >= value.into(), Error::<T>::TokenValueTooLow);17351736        // update balance1737        let balance_old_owner = <Balance<T>>::get(collection_id, owner.clone())1738            .checked_sub(value)1739            .ok_or(Error::<T>::NumOverflow)?;1740        <Balance<T>>::insert(collection_id, owner.clone(), balance_old_owner);17411742        let mut new_owner_account_id = 0;1743        let new_owner_items = <AddressTokens<T>>::get(collection_id, new_owner.clone());1744        if new_owner_items.len() > 0 {1745            new_owner_account_id = new_owner_items[0];1746        }17471748        let val64 = value.into();17491750        // transfer1751        if amount == val64 && new_owner_account_id == 0 {1752            // change owner1753            // new owner do not have account1754            let mut new_full_item = full_item.clone();1755            new_full_item.owner = new_owner.clone();1756            <FungibleItemList<T>>::insert(collection_id, item_id, new_full_item);17571758            // update balance1759            let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.clone())1760                .checked_add(value)1761                .ok_or(Error::<T>::NumOverflow)?;1762            <Balance<T>>::insert(collection_id, new_owner.clone(), balance_new_owner);17631764            // update index collection1765            Self::move_token_index(collection_id, item_id, owner.clone(), new_owner.clone())?;1766        } else {1767            let mut new_full_item = full_item.clone();1768            new_full_item.value -= val64;17691770            // separate amount1771            if new_owner_account_id > 0 {1772                // new owner has account1773                let mut item = <FungibleItemList<T>>::get(collection_id, new_owner_account_id);1774                item.value += val64;17751776                // update balance1777                let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.clone())1778                    .checked_add(value)1779                    .ok_or(Error::<T>::NumOverflow)?;1780                <Balance<T>>::insert(collection_id, new_owner.clone(), balance_new_owner);17811782                <FungibleItemList<T>>::insert(collection_id, new_owner_account_id, item);1783            } else {1784                // new owner do not have account1785                let item = FungibleItemType {1786                    collection: collection_id,1787                    owner: new_owner.clone(),1788                    value: val64,1789                };17901791                Self::add_fungible_item(item)?;1792            }17931794            if amount == val64 {1795                Self::remove_token_index(collection_id, item_id, full_item.owner.clone())?;17961797                // remove approve list1798                <ApprovedList<T>>::remove(collection_id, (item_id, full_item.owner.clone()));1799                <FungibleItemList<T>>::remove(collection_id, item_id);1800            }18011802            <FungibleItemList<T>>::insert(collection_id, item_id, new_full_item);1803        }18041805        Ok(())1806    }18071808    fn transfer_refungible(1809        collection_id: u64,1810        item_id: u64,1811        value: u64,1812        owner: T::AccountId,1813        new_owner: T::AccountId,1814    ) -> DispatchResult {1815        ensure!(1816            <ReFungibleItemList<T>>::contains_key(collection_id, item_id),1817            Error::<T>::TokenNotFound1818        );18191820        let full_item = <ReFungibleItemList<T>>::get(collection_id, item_id);1821        let item = full_item1822            .owner1823            .iter()1824            .filter(|i| i.owner == owner)1825            .next()1826            .ok_or(Error::<T>::NumOverflow)?;1827        let amount = item.fraction;18281829        ensure!(amount >= value.into(), Error::<T>::TokenValueTooLow);18301831        // update balance1832        let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())1833            .checked_sub(value)1834            .ok_or(Error::<T>::NumOverflow)?;1835        <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);18361837        let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.clone())1838            .checked_add(value)1839            .ok_or(Error::<T>::NumOverflow)?;1840        <Balance<T>>::insert(collection_id, new_owner.clone(), balance_new_owner);18411842        let old_owner = item.owner.clone();1843        let new_owner_has_account = full_item.owner.iter().any(|i| i.owner == new_owner);1844        let val64 = value.into();18451846        // transfer1847        if amount == val64 && !new_owner_has_account {1848            // change owner1849            // new owner do not have account1850            let mut new_full_item = full_item.clone();1851            new_full_item1852                .owner1853                .iter_mut()1854                .find(|i| i.owner == owner)1855                .unwrap()1856                .owner = new_owner.clone();1857            <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);18581859            // update index collection1860            Self::move_token_index(collection_id, item_id, old_owner.clone(), new_owner.clone())?;1861        } else {1862            let mut new_full_item = full_item.clone();1863            new_full_item1864                .owner1865                .iter_mut()1866                .find(|i| i.owner == owner)1867                .unwrap()1868                .fraction -= val64;18691870            // separate amount1871            if new_owner_has_account {1872                // new owner has account1873                new_full_item1874                    .owner1875                    .iter_mut()1876                    .find(|i| i.owner == new_owner)1877                    .unwrap()1878                    .fraction += val64;1879            } else {1880                // new owner do not have account1881                new_full_item.owner.push(Ownership {1882                    owner: new_owner.clone(),1883                    fraction: val64,1884                });1885                Self::add_token_index(collection_id, item_id, new_owner.clone())?;1886            }18871888            <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);1889        }18901891        Ok(())1892    }18931894    fn transfer_nft(1895        collection_id: u64,1896        item_id: u64,1897        sender: T::AccountId,1898        new_owner: T::AccountId,1899    ) -> DispatchResult {1900        ensure!(1901            <NftItemList<T>>::contains_key(collection_id, item_id),1902            Error::<T>::TokenNotFound1903        );19041905        let mut item = <NftItemList<T>>::get(collection_id, item_id);19061907        ensure!(1908            sender == item.owner,1909            Error::<T>::MustBeTokenOwner1910        );19111912        // update balance1913        let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())1914            .checked_sub(1)1915            .ok_or(Error::<T>::NumOverflow)?;1916        <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);19171918        let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.clone())1919            .checked_add(1)1920            .ok_or(Error::<T>::NumOverflow)?;1921        <Balance<T>>::insert(collection_id, new_owner.clone(), balance_new_owner);19221923        // change owner1924        let old_owner = item.owner.clone();1925        item.owner = new_owner.clone();1926        <NftItemList<T>>::insert(collection_id, item_id, item);19271928        // update index collection1929        Self::move_token_index(collection_id, item_id, old_owner.clone(), new_owner.clone())?;19301931        // reset approved list1932        <ApprovedList<T>>::remove(collection_id, (item_id, old_owner));1933        Ok(())1934    }1935    1936    fn item_exists(1937        collection_id: u64,1938        item_id: u64,1939        mode: &CollectionMode1940    ) -> DispatchResult {1941        match mode {1942            CollectionMode::NFT => ensure!(<NftItemList<T>>::contains_key(collection_id, item_id), Error::<T>::TokenNotFound),1943            CollectionMode::ReFungible(_) => ensure!(<ReFungibleItemList<T>>::contains_key(collection_id, item_id), Error::<T>::TokenNotFound),1944            CollectionMode::Fungible(_) => ensure!(<FungibleItemList<T>>::contains_key(collection_id, item_id), Error::<T>::TokenNotFound),1945            _ => ()1946        };1947        1948        Ok(())1949    }19501951    fn set_re_fungible_variable_data(1952        collection_id: u64,1953        item_id: u64,1954        data: Vec<u8>1955    ) -> DispatchResult {1956        let mut item = <ReFungibleItemList<T>>::get(collection_id, item_id);19571958        item.variable_data = data;19591960        <ReFungibleItemList<T>>::insert(collection_id, item_id, item);19611962        Ok(())1963    }19641965    fn set_nft_variable_data(1966        collection_id: u64,1967        item_id: u64,1968        data: Vec<u8>1969    ) -> DispatchResult {1970        let mut item = <NftItemList<T>>::get(collection_id, item_id);1971        1972        item.variable_data = data;19731974        <NftItemList<T>>::insert(collection_id, item_id, item);1975        1976        Ok(())1977    }19781979    fn init_collection(item: &CollectionType<T::AccountId>) {1980        // check params1981        assert!(1982            item.decimal_points <= 4,1983            "decimal_points parameter must be lower than 4"1984        );1985        assert!(1986            item.name.len() <= 64,1987            "Collection name can not be longer than 63 char"1988        );1989        assert!(1990            item.name.len() <= 256,1991            "Collection description can not be longer than 255 char"1992        );1993        assert!(1994            item.token_prefix.len() <= 16,1995            "Token prefix can not be longer than 15 char"1996        );19971998        // Generate next collection ID1999        let next_id = CreatedCollectionCount::get()2000            .checked_add(1)2001            .unwrap();20022003        CreatedCollectionCount::put(next_id);2004    }20052006    fn init_nft_token(item: &NftItemType<T::AccountId>) {2007        let current_index = <ItemListIndex>::get(item.collection)2008            .checked_add(1)2009            .unwrap();20102011        let item_owner = item.owner.clone();2012        let collection_id = item.collection.clone();2013        Self::add_token_index(collection_id, current_index, item.owner.clone()).unwrap();20142015        <ItemListIndex>::insert(collection_id, current_index);20162017        // Update balance2018        let new_balance = <Balance<T>>::get(collection_id, item_owner.clone())2019            .checked_add(1)2020            .unwrap();2021        <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);2022    }20232024    fn init_fungible_token(item: &FungibleItemType<T::AccountId>) {2025        let current_index = <ItemListIndex>::get(item.collection)2026            .checked_add(1)2027            .unwrap();2028        let owner = item.owner.clone();2029        let value = item.value as u64;20302031        Self::add_token_index(item.collection, current_index, owner.clone()).unwrap();20322033        <ItemListIndex>::insert(item.collection, current_index);20342035        // Update balance2036        let new_balance = <Balance<T>>::get(item.collection, owner.clone())2037            .checked_add(value)2038            .unwrap();2039        <Balance<T>>::insert(item.collection, owner.clone(), new_balance);2040    }20412042    fn init_refungible_token(item: &ReFungibleItemType<T::AccountId>) {2043        let current_index = <ItemListIndex>::get(item.collection)2044            .checked_add(1)2045            .unwrap();20462047        let value = item.owner.first().unwrap().fraction as u64;2048        let owner = item.owner.first().unwrap().owner.clone();20492050        Self::add_token_index(item.collection, current_index, owner.clone()).unwrap();20512052        <ItemListIndex>::insert(item.collection, current_index);20532054        // Update balance2055        let new_balance = <Balance<T>>::get(item.collection, owner.clone())2056            .checked_add(value)2057            .unwrap();2058        <Balance<T>>::insert(item.collection, owner.clone(), new_balance);2059    }20602061    fn add_token_index(collection_id: u64, item_index: u64, owner: T::AccountId) -> DispatchResult {20622063        // add to account limit2064        if <AccountItemCount<T>>::contains_key(owner.clone()) {20652066            // bound Owned tokens by a single address2067            let count = <AccountItemCount<T>>::get(owner.clone());2068            ensure!(count < ChainLimit::get().account_token_ownership_limit, Error::<T>::AddressOwnershipLimitExceeded);20692070            <AccountItemCount<T>>::insert(owner.clone(), count2071                .checked_add(1)2072                .ok_or(Error::<T>::NumOverflow)?);2073        }2074        else {2075            <AccountItemCount<T>>::insert(owner.clone(), 1);2076        }20772078        let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner.clone());2079        if list_exists {2080            let mut list = <AddressTokens<T>>::get(collection_id, owner.clone());2081            let item_contains = list.contains(&item_index.clone());20822083            if !item_contains {2084                list.push(item_index.clone());2085            }20862087            <AddressTokens<T>>::insert(collection_id, owner.clone(), list);2088        } else {2089            let mut itm = Vec::new();2090            itm.push(item_index.clone());2091            <AddressTokens<T>>::insert(collection_id, owner, itm);2092            2093        }20942095        Ok(())2096    }20972098    fn remove_token_index(2099        collection_id: u64,2100        item_index: u64,2101        owner: T::AccountId,2102    ) -> DispatchResult {21032104        // update counter2105        <AccountItemCount<T>>::insert(owner.clone(), 2106            <AccountItemCount<T>>::get(owner.clone())2107            .checked_sub(1)2108            .ok_or(Error::<T>::NumOverflow)?);210921102111        let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner.clone());2112        if list_exists {2113            let mut list = <AddressTokens<T>>::get(collection_id, owner.clone());2114            let item_contains = list.contains(&item_index.clone());21152116            if item_contains {2117                list.retain(|&item| item != item_index);2118                <AddressTokens<T>>::insert(collection_id, owner, list);2119            }2120        }21212122        Ok(())2123    }21242125    fn move_token_index(2126        collection_id: u64,2127        item_index: u64,2128        old_owner: T::AccountId,2129        new_owner: T::AccountId,2130    ) -> DispatchResult {2131        Self::remove_token_index(collection_id, item_index, old_owner)?;2132        Self::add_token_index(collection_id, item_index, new_owner)?;21332134        Ok(())2135    }2136}21372138////////////////////////////////////////////////////////////////////////////////////////////////////2139// Economic models2140// #region21412142/// Fee multiplier.2143pub type Multiplier = FixedU128;21442145type BalanceOf<T> = <<T as transaction_payment::Trait>::Currency as Currency<2146    <T as system::Trait>::AccountId,2147>>::Balance;2148type NegativeImbalanceOf<T> = <<T as transaction_payment::Trait>::Currency as Currency<2149    <T as system::Trait>::AccountId,2150>>::NegativeImbalance;21512152/// Require the transactor pay for themselves and maybe include a tip to gain additional priority2153/// in the queue.2154#[derive(Encode, Decode, Clone, Eq, PartialEq)]2155pub struct ChargeTransactionPayment<T: Trait + Send + Sync>(2156    #[codec(compact)] BalanceOf<T>2157);21582159impl<T: Trait + Send + Sync> sp_std::fmt::Debug2160    for ChargeTransactionPayment<T>2161{2162    #[cfg(feature = "std")]2163    fn fmt(&self, f: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {2164        write!(f, "ChargeTransactionPayment<{:?}>", self.0)2165    }2166    #[cfg(not(feature = "std"))]2167    fn fmt(&self, _: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {2168        Ok(())2169    }2170}21712172impl<T: Trait + Send + Sync> ChargeTransactionPayment<T>2173where2174    T::Call: Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,2175    BalanceOf<T>: Send + Sync + FixedPointOperand,2176{2177    /// utility constructor. Used only in client/factory code.2178    pub fn from(fee: BalanceOf<T>) -> Self {2179        Self(fee)2180    }21812182    pub fn traditional_fee(2183        len: usize,2184        info: &DispatchInfoOf<T::Call>,2185        tip: BalanceOf<T>,2186    ) -> BalanceOf<T>2187    where2188        T::Call: Dispatchable<Info = DispatchInfo>,2189    {2190        <transaction_payment::Module<T>>::compute_fee(len as u32, info, tip)2191    }21922193    fn withdraw_fee(2194        &self,2195        who: &T::AccountId,2196        call: &T::Call,2197        info: &DispatchInfoOf<T::Call>,2198        len: usize,2199    ) -> Result<(BalanceOf<T>, Option<NegativeImbalanceOf<T>>), TransactionValidityError> {2200        let tip = self.0;22012202        // Set fee based on call type. Creating collection costs 1 Unique.2203        // All other transactions have traditional fees so far2204        // let fee = match call.is_sub_type() {2205        //     Some(Call::create_collection(..)) => <BalanceOf<T>>::from(1_000_000_000),2206        //     _ => Self::traditional_fee(len, info, tip), // Flat fee model, use only for testing purposes2207        //                                                 // _ => <BalanceOf<T>>::from(100)2208        // };2209        let fee = Self::traditional_fee(len, info, tip);22102211        // Determine who is paying transaction fee based on ecnomic model2212        // Parse call to extract collection ID and access collection sponsor2213        let mut sponsor: T::AccountId = match IsSubType::<Call<T>>::is_sub_type(call) {2214            Some(Call::create_item(collection_id, _properties, _owner)) => {2215                <Collection<T>>::get(collection_id).sponsor2216            }2217            Some(Call::transfer(_new_owner, collection_id, _item_id, _value)) => {2218                let _collection_mode = <Collection<T>>::get(collection_id).mode;22192220                // sponsor timeout2221                let sponsor_transfer = match _collection_mode {2222                    CollectionMode::NFT => {2223                        let basket = <NftTransferBasket<T>>::get(collection_id, _item_id);2224                        let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2225                        let limit_time = basket + ChainLimit::get().nft_sponsor_transfer_timeout.into();2226                        if block_number >= limit_time {2227                            <NftTransferBasket<T>>::insert(collection_id, _item_id, block_number);2228                            true2229                        }2230                        else {2231                            false2232                        }2233                    }2234                    CollectionMode::Fungible(_) => {2235                        let mut basket = <FungibleTransferBasket<T>>::get(collection_id, _item_id);2236                        let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2237                        if basket.iter().any(|i| i.address == _new_owner.clone())2238                        {2239                            let item = basket.iter_mut().find(|i| i.address == _new_owner.clone()).unwrap().clone();2240                            let limit_time = item.start_block + ChainLimit::get().fungible_sponsor_transfer_timeout.into();2241                            if block_number >= limit_time {2242                                basket.retain(|x| x.address == item.address);2243                                basket.push(BasketItem { start_block: block_number, address: _new_owner.clone() });2244                                <FungibleTransferBasket<T>>::insert(collection_id, _item_id, basket);2245                                true2246                            }2247                            else {2248                                false2249                            }2250                        }2251                        else {2252                            basket.push(BasketItem { start_block: block_number, address: _new_owner.clone()});2253                            true2254                        }2255                    }2256                    CollectionMode::ReFungible(_) => {2257                        let basket = <ReFungibleTransferBasket<T>>::get(collection_id, _item_id);2258                        let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2259                        let limit_time = basket + ChainLimit::get().nft_sponsor_transfer_timeout.into();2260                        if block_number >= limit_time {2261                            <ReFungibleTransferBasket<T>>::insert(collection_id, _item_id, block_number);2262                            true2263                        } else {2264                            false2265                        }2266                    }2267                    _ => {2268                        false2269                    },2270                };22712272                if !sponsor_transfer {2273                    T::AccountId::default()2274                } else {2275                    <Collection<T>>::get(collection_id).sponsor2276                }2277            }22782279            _ => T::AccountId::default(),2280        };22812282        // Sponsor smart contracts2283        sponsor = match IsSubType::<pallet_contracts::Call<T>>::is_sub_type(call) {22842285            // On instantiation: set the contract owner2286            Some(pallet_contracts::Call::instantiate(_endowment, _gas_limit, code_hash, data)) => {22872288                let new_contract_address = <T as pallet_contracts::Trait>::DetermineContractAddress::contract_address_for(2289                    code_hash,2290                    &data,2291                    &who,2292                );2293                <ContractOwner<T>>::insert(new_contract_address.clone(), who.clone());22942295                T::AccountId::default()2296            },22972298            // When the contract is called, check if the sponsoring is enabled and pay fees from contract endowment if it is2299            Some(pallet_contracts::Call::call(dest, _value, _gas_limit, _data)) => {23002301                let called_contract: T::AccountId = T::Lookup::lookup((*dest).clone()).unwrap_or(T::AccountId::default());23022303                let mut sponsor_transfer = false;2304                if <ContractSponsoringRateLimit<T>>::contains_key(called_contract.clone()) {2305                    let last_tx_block = <ContractSponsorBasket<T>>::get(&called_contract);2306                    let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2307                    let rate_limit = <ContractSponsoringRateLimit<T>>::get(&called_contract);2308                    let limit_time = last_tx_block + rate_limit;23092310                    if block_number >= limit_time {2311                        <ContractSponsorBasket<T>>::insert(called_contract.clone(), block_number);2312                        sponsor_transfer = true;2313                    }2314                } else {2315                    sponsor_transfer = false;2316                }2317               2318                2319                let mut sp = T::AccountId::default();2320                if sponsor_transfer {2321                    if <ContractSelfSponsoring<T>>::contains_key(called_contract.clone()) {2322                        if <ContractSelfSponsoring<T>>::get(called_contract.clone()) {2323                            sp = called_contract;2324                        }2325                    }2326                }23272328                sp2329            },23302331            _ => sponsor,2332        };23332334        let mut who_pays_fee: T::AccountId = sponsor.clone();2335        if sponsor == T::AccountId::default() {2336            who_pays_fee = who.clone();2337        }23382339        // Only mess with balances if fee is not zero.2340        if fee.is_zero() {2341            return Ok((fee, None));2342        }23432344        match <T as transaction_payment::Trait>::Currency::withdraw(2345            &who_pays_fee,2346            fee,2347            if tip.is_zero() {2348                WithdrawReason::TransactionPayment.into()2349            } else {2350                WithdrawReason::TransactionPayment | WithdrawReason::Tip2351            },2352            ExistenceRequirement::KeepAlive,2353        ) {2354            Ok(imbalance) => Ok((fee, Some(imbalance))),2355            Err(_) => Err(InvalidTransaction::Payment.into()),2356        }2357    }2358}235923602361impl<T: Trait + Send + Sync> SignedExtension2362    for ChargeTransactionPayment<T>2363where2364    BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,2365    T::Call: Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,2366{2367    const IDENTIFIER: &'static str = "ChargeTransactionPayment";2368    type AccountId = T::AccountId;2369    type Call = T::Call;2370    type AdditionalSigned = ();2371    type Pre = (2372        BalanceOf<T>,2373        Self::AccountId,2374        Option<NegativeImbalanceOf<T>>,2375        BalanceOf<T>,2376    );2377    fn additional_signed(&self) -> sp_std::result::Result<(), TransactionValidityError> {2378        Ok(())2379    }23802381    fn validate(2382        &self,2383        _who: &Self::AccountId,2384        _call: &Self::Call,2385        _info: &DispatchInfoOf<Self::Call>,2386        _len: usize,2387    ) -> TransactionValidity {2388        Ok(ValidTransaction::default())2389    }23902391    fn pre_dispatch(2392        self,2393        who: &Self::AccountId,2394        call: &Self::Call,2395        info: &DispatchInfoOf<Self::Call>,2396        len: usize,2397    ) -> Result<Self::Pre, TransactionValidityError> {2398        let (fee, imbalance) = self.withdraw_fee(who, call, info, len)?;2399        Ok((self.0, who.clone(), imbalance, fee))2400    }24012402    fn post_dispatch(2403        pre: Self::Pre,2404        info: &DispatchInfoOf<Self::Call>,2405        post_info: &PostDispatchInfoOf<Self::Call>,2406        len: usize,2407        _result: &DispatchResult,2408    ) -> Result<(), TransactionValidityError> {2409        let (tip, who, imbalance, fee) = pre;2410        if let Some(payed) = imbalance {2411            let actual_fee = <transaction_payment::Module<T>>::compute_actual_fee(2412                len as u32, info, post_info, tip,2413            );2414            let refund = fee.saturating_sub(actual_fee);2415            let actual_payment =2416                match <T as transaction_payment::Trait>::Currency::deposit_into_existing(2417                    &who, refund,2418                ) {2419                    Ok(refund_imbalance) => {2420                        // The refund cannot be larger than the up front payed max weight.2421                        // `PostDispatchInfo::calc_unspent` guards against such a case.2422                        match payed.offset(refund_imbalance) {2423                            Ok(actual_payment) => actual_payment,2424                            Err(_) => return Err(InvalidTransaction::Payment.into()),2425                        }2426                    }2427                    // We do not recreate the account using the refund. The up front payment2428                    // is gone in that case.2429                    Err(_) => payed,2430                };2431            let imbalances = actual_payment.split(tip);2432            <T as transaction_payment::Trait>::OnTransactionPayment::on_unbalanceds(2433                Some(imbalances.0).into_iter().chain(Some(imbalances.1)),2434            );2435        }2436        Ok(())2437    }2438}24392440// #endregion