git.delta.rocks / unique-network / refs/commits / 0c172129d62b

1//2// This file is subject to the terms and conditions defined in3// file 'LICENSE', which is part of this source code package.4//56#![recursion_limit = "1024"]78#![cfg_attr(not(feature = "std"), no_std)]910#[cfg(feature = "std")]11pub use std::*;1213#[cfg(feature = "std")]14pub use serde::*;1516use codec::{Decode, Encode};17pub use frame_support::{18    construct_runtime, decl_event, decl_module, decl_storage, decl_error,19    dispatch::DispatchResult,20    ensure, fail, parameter_types,21    traits::{22        Currency, ExistenceRequirement, Get, Imbalance, KeyOwnerProofSystem, OnUnbalanced,23        Randomness, IsSubType,24    },25    weights::{26        constants::{BlockExecutionWeight, ExtrinsicBaseWeight, RocksDbWeight, WEIGHT_PER_SECOND},27        DispatchInfo, GetDispatchInfo, IdentityFee, Pays, PostDispatchInfo, Weight,28        WeightToFeePolynomial, DispatchClass,29    },30    StorageValue,31};3233use frame_system::{self as system, ensure_signed, ensure_root};34use sp_runtime::sp_std::prelude::Vec;35use sp_runtime::{36    traits::{37        Hash, DispatchInfoOf, Dispatchable, PostDispatchInfoOf, Saturating, SaturatedConversion, SignedExtension, Zero,38    },39    transaction_validity::{40        TransactionPriority, InvalidTransaction, TransactionValidity, TransactionValidityError, ValidTransaction,41    },42    FixedPointOperand, FixedU128,43};44use sp_runtime::traits::StaticLookup;45use pallet_contracts::chain_extension::UncheckedFrom;46use pallet_transaction_payment::OnChargeTransaction;4748#[cfg(test)]49mod mock;5051#[cfg(test)]52mod tests;5354mod default_weights;5556pub const MAX_DECIMAL_POINTS: DecimalPoints = 30;57pub const MAX_REFUNGIBLE_PIECES: u128 = 1_000_000_000_000_000_000_000;58pub const MAX_SPONSOR_TIMEOUT: u32 = 10_368_000;59pub const MAX_TOKEN_OWNERSHIP: u32 = 10_000_000;6061// Structs62// #region6364pub type CollectionId = u32;65pub type TokenId = u32;66pub type DecimalPoints = u8;6768#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq)]69#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]70pub enum CollectionMode {71    Invalid,72    NFT,73    // decimal points74    Fungible(DecimalPoints),75    ReFungible,76}7778impl Default for CollectionMode {79    fn default() -> Self {80        Self::Invalid81    }82}8384impl Into<u8> for CollectionMode {85    fn into(self) -> u8 {86        match self {87            CollectionMode::Invalid => 0,88            CollectionMode::NFT => 1,89            CollectionMode::Fungible(_) => 2,90            CollectionMode::ReFungible => 3,91        }92    }93}9495#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq)]96#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]97pub enum AccessMode {98    Normal,99    WhiteList,100}101impl Default for AccessMode {102    fn default() -> Self {103        Self::Normal104    }105}106107#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq)]108#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]109pub enum SchemaVersion {110    ImageURL,111    Unique,112}113impl Default for SchemaVersion {114    fn default() -> Self {115        Self::ImageURL116    }117}118119#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]120#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]121pub struct Ownership<AccountId> {122    pub owner: AccountId,123    pub fraction: u128,124}125126#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]127#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]128pub struct CollectionType<AccountId> {129    pub owner: AccountId,130    pub mode: CollectionMode,131    pub access: AccessMode,132    pub decimal_points: DecimalPoints,133    pub name: Vec<u16>,        // 64 include null escape char134    pub description: Vec<u16>, // 256 include null escape char135    pub token_prefix: Vec<u8>, // 16 include null escape char136    pub mint_mode: bool,137    pub offchain_schema: Vec<u8>,138    pub schema_version: SchemaVersion,139    pub sponsor: AccountId, // Who pays fees. If set to default address, the fees are applied to the transaction sender140    pub sponsor_confirmed: bool, // False if sponsor address has not yet confirmed sponsorship. True otherwise.141    pub limits: CollectionLimits, // Collection private restrictions 142    pub variable_on_chain_schema: Vec<u8>, //143    pub const_on_chain_schema: Vec<u8>, //144}145146#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]147#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]148pub struct NftItemType<AccountId> {149    pub owner: AccountId,150    pub const_data: Vec<u8>,151    pub variable_data: Vec<u8>,152}153154#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]155#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]156pub struct FungibleItemType {157    pub value: u128,158}159160#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]161#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]162pub struct ReFungibleItemType<AccountId> {163    pub owner: Vec<Ownership<AccountId>>,164    pub const_data: Vec<u8>,165    pub variable_data: Vec<u8>,166}167168// #[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]169// #[cfg_attr(feature = "std", derive(Serialize, Deserialize))]170// pub struct VestingItem<AccountId, Moment> {171//     pub sender: AccountId,172//     pub recipient: AccountId,173//     pub collection_id: CollectionId,174//     pub item_id: TokenId,175//     pub amount: u64,176//     pub vesting_date: Moment,177// }178179#[derive(Encode, Decode, Debug, Clone, PartialEq)]180#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]181pub struct CollectionLimits {182    pub account_token_ownership_limit: u32,183    pub sponsored_data_size: u32,184    pub token_limit: u32,185186    // Timeouts for item types in passed blocks187    pub sponsor_transfer_timeout: u32,188    pub owner_can_transfer: bool,189    pub owner_can_destroy: bool,190}191192impl Default for CollectionLimits {193    fn default() -> CollectionLimits {194        CollectionLimits { 195            account_token_ownership_limit: 10_000_000, 196            token_limit: u32::max_value(),197            sponsored_data_size: u32::MAX,198            sponsor_transfer_timeout: 14400,199            owner_can_transfer: true,200            owner_can_destroy: true201        }202    }203}204205#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]206#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]207pub struct ChainLimits {208    pub collection_numbers_limit: u32,209    pub account_token_ownership_limit: u32,210    pub collections_admins_limit: u64,211    pub custom_data_limit: u32,212213    // Timeouts for item types in passed blocks214    pub nft_sponsor_transfer_timeout: u32,215    pub fungible_sponsor_transfer_timeout: u32,216    pub refungible_sponsor_transfer_timeout: u32,217218    // Schema limits219    pub offchain_schema_limit: u32,220    pub variable_on_chain_schema_limit: u32,221    pub const_on_chain_schema_limit: u32,222}223224pub trait WeightInfo {225	fn create_collection() -> Weight;226	fn destroy_collection() -> Weight;227	fn add_to_white_list() -> Weight;228	fn remove_from_white_list() -> Weight;229    fn set_public_access_mode() -> Weight;230    fn set_mint_permission() -> Weight;231    fn change_collection_owner() -> Weight;232    fn add_collection_admin() -> Weight;233    fn remove_collection_admin() -> Weight;234    fn set_collection_sponsor() -> Weight;235    fn confirm_sponsorship() -> Weight;236    fn remove_collection_sponsor() -> Weight;237    fn create_item(s: usize) -> Weight;238    fn burn_item() -> Weight;239    fn transfer() -> Weight;240    fn approve() -> Weight;241    fn transfer_from() -> Weight;242    fn set_offchain_schema() -> Weight;243    fn set_const_on_chain_schema() -> Weight;244    fn set_variable_on_chain_schema() -> Weight;245    fn set_variable_meta_data() -> Weight;246    fn enable_contract_sponsoring() -> Weight;247    fn set_schema_version() -> Weight;248    fn set_chain_limits() -> Weight;249    fn set_contract_sponsoring_rate_limit() -> Weight;250    fn toggle_contract_white_list() -> Weight;251    fn add_to_contract_white_list() -> Weight;252    fn remove_from_contract_white_list() -> Weight;253    fn set_collection_limits() -> Weight;254}255256#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]257#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]258pub struct CreateNftData {259    pub const_data: Vec<u8>,260    pub variable_data: Vec<u8>,261}262263#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]264#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]265pub struct CreateFungibleData {266    pub value: u128,267}268269#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]270#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]271pub struct CreateReFungibleData {272    pub const_data: Vec<u8>,273    pub variable_data: Vec<u8>,274    pub pieces: u128,275}276277#[derive(Encode, Decode, Debug, Clone, PartialEq)]278#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]279pub enum CreateItemData {280    NFT(CreateNftData),281    Fungible(CreateFungibleData),282    ReFungible(CreateReFungibleData),283}284285impl CreateItemData {286    pub fn len(&self) -> usize {287        let len = match self {288            CreateItemData::NFT(data) => data.variable_data.len() + data.const_data.len(),289            CreateItemData::ReFungible(data) => data.variable_data.len() + data.const_data.len(),290            _ => 0291        };292        293        return len;294    }295}296297impl From<CreateNftData> for CreateItemData {298    fn from(item: CreateNftData) -> Self {299        CreateItemData::NFT(item)300    }301}302303impl From<CreateReFungibleData> for CreateItemData {304    fn from(item: CreateReFungibleData) -> Self {305        CreateItemData::ReFungible(item)306    }307}308309impl From<CreateFungibleData> for CreateItemData {310    fn from(item: CreateFungibleData) -> Self {311        CreateItemData::Fungible(item)312    }313}314315316decl_error! {317	/// Error for non-fungible-token module.318	pub enum Error for Module<T: Config> {319        /// Total collections bound exceeded.320        TotalCollectionsLimitExceeded,321		/// Decimal_points parameter must be lower than MAX_DECIMAL_POINTS constant, currently it is 30.322        CollectionDecimalPointLimitExceeded, 323        /// Collection name can not be longer than 63 char.324        CollectionNameLimitExceeded, 325        /// Collection description can not be longer than 255 char.326        CollectionDescriptionLimitExceeded, 327        /// Token prefix can not be longer than 15 char.328        CollectionTokenPrefixLimitExceeded,329        /// This collection does not exist.330        CollectionNotFound,331        /// Item not exists.332        TokenNotFound,333        /// Admin not found334        AdminNotFound,335        /// Arithmetic calculation overflow.336        NumOverflow,       337        /// Account already has admin role.338        AlreadyAdmin,  339        /// You do not own this collection.340        NoPermission,341        /// This address is not set as sponsor, use setCollectionSponsor first.342        ConfirmUnsetSponsorFail,343        /// Collection is not in mint mode.344        PublicMintingNotAllowed,345        /// Sender parameter and item owner must be equal.346        MustBeTokenOwner,347        /// Item balance not enough.348        TokenValueTooLow,349        /// Size of item is too large.350        NftSizeLimitExceeded,351        /// No approve found352        ApproveNotFound,353        /// Requested value more than approved.354        TokenValueNotEnough,355        /// Only approved addresses can call this method.356        ApproveRequired,357        /// Address is not in white list.358        AddresNotInWhiteList,359        /// Number of collection admins bound exceeded.360        CollectionAdminsLimitExceeded,361        /// Owned tokens by a single address bound exceeded.362        AddressOwnershipLimitExceeded,363        /// Length of items properties must be greater than 0.364        EmptyArgument,365        /// const_data exceeded data limit.366        TokenConstDataLimitExceeded,367        /// variable_data exceeded data limit.368        TokenVariableDataLimitExceeded,369        /// Not NFT item data used to mint in NFT collection.370        NotNftDataUsedToMintNftCollectionToken,371        /// Not Fungible item data used to mint in Fungible collection.372        NotFungibleDataUsedToMintFungibleCollectionToken,373        /// Not Re Fungible item data used to mint in Re Fungible collection.374        NotReFungibleDataUsedToMintReFungibleCollectionToken,375        /// Unexpected collection type.376        UnexpectedCollectionType,377        /// Can't store metadata in fungible tokens.378        CantStoreMetadataInFungibleTokens,379        /// Collection token limit exceeded380        CollectionTokenLimitExceeded,381        /// Account token limit exceeded per collection382        AccountTokenLimitExceeded,383        /// Collection limit bounds per collection exceeded384        CollectionLimitBoundsExceeded,385        /// Tried to enable permissions which are only permitted to be disabled386        OwnerPermissionsCantBeReverted,387        /// Schema data size limit bound exceeded388        SchemaDataLimitExceeded,389        /// Maximum refungibility exceeded390        WrongRefungiblePieces391	}392}393394pub trait Config: system::Config + Sized + pallet_transaction_payment::Config + pallet_contracts::Config {395    type Event: From<Event<Self>> + Into<<Self as system::Config>::Event>;396397    /// Weight information for extrinsics in this pallet.398	type WeightInfo: WeightInfo;399}400401#[cfg(feature = "runtime-benchmarks")]402mod benchmarking;403404// #endregion405406decl_storage! {407    trait Store for Module<T: Config> as Nft {408409        // Private members410        NextCollectionID: CollectionId;411        CreatedCollectionCount: u32;412        ChainVersion: u64;413        ItemListIndex: map hasher(identity) CollectionId => TokenId;414415        // Chain limits struct416        pub ChainLimit get(fn chain_limit) config(): ChainLimits;417418        // Bound counters419        CollectionCount: u32;420        pub AccountItemCount get(fn account_item_count): map hasher(twox_64_concat) T::AccountId => u32;421422        // Basic collections423        pub Collection get(fn collection) config(): map hasher(identity) CollectionId => CollectionType<T::AccountId>;424        pub AdminList get(fn admin_list_collection): map hasher(identity) CollectionId => Vec<T::AccountId>;425        pub WhiteList get(fn white_list): double_map hasher(identity) CollectionId, hasher(twox_64_concat) T::AccountId => bool;426427        /// Balance owner per collection map428        pub Balance get(fn balance_count): double_map hasher(identity) CollectionId, hasher(twox_64_concat) T::AccountId => u128;429430        /// second parameter: item id + owner account id + spender account id431        pub Allowances get(fn approved): double_map hasher(identity) CollectionId, hasher(twox_64_concat) (TokenId, T::AccountId, T::AccountId) => u128;432433        /// Item collections434        pub NftItemList get(fn nft_item_id) config(): double_map hasher(identity) CollectionId, hasher(identity) TokenId => NftItemType<T::AccountId>;435        pub FungibleItemList get(fn fungible_item_id) config(): double_map hasher(identity) CollectionId, hasher(twox_64_concat) T::AccountId => FungibleItemType;436        pub ReFungibleItemList get(fn refungible_item_id) config(): double_map hasher(identity) CollectionId, hasher(identity) TokenId => ReFungibleItemType<T::AccountId>;437438        /// Index list439        pub AddressTokens get(fn address_tokens): double_map hasher(identity) CollectionId, hasher(twox_64_concat) T::AccountId => Vec<TokenId>;440441        /// Tokens transfer baskets442        pub CreateItemBasket get(fn create_item_basket): map hasher(twox_64_concat) (CollectionId, T::AccountId) => T::BlockNumber;443        pub NftTransferBasket get(fn nft_transfer_basket): double_map hasher(identity) CollectionId, hasher(identity) TokenId => T::BlockNumber;444        pub FungibleTransferBasket get(fn fungible_transfer_basket): double_map hasher(identity) CollectionId, hasher(twox_64_concat) T::AccountId => T::BlockNumber;445        pub ReFungibleTransferBasket get(fn refungible_transfer_basket): double_map hasher(identity) CollectionId, hasher(identity) TokenId => T::BlockNumber;446447        // Contract Sponsorship and Ownership448        pub ContractOwner get(fn contract_owner): map hasher(twox_64_concat) T::AccountId => T::AccountId;449        pub ContractSelfSponsoring get(fn contract_self_sponsoring): map hasher(twox_64_concat) T::AccountId => bool;450        pub ContractSponsorBasket get(fn contract_sponsor_basket): map hasher(twox_64_concat) (T::AccountId, T::AccountId) => T::BlockNumber;451        pub ContractSponsoringRateLimit get(fn contract_sponsoring_rate_limit): map hasher(twox_64_concat) T::AccountId => T::BlockNumber;452        pub ContractWhiteListEnabled get(fn contract_white_list_enabled): map hasher(twox_64_concat) T::AccountId => bool; 453        pub ContractWhiteList get(fn contract_white_list): double_map hasher(twox_64_concat) T::AccountId, hasher(twox_64_concat) T::AccountId => bool; 454    }455    add_extra_genesis {456        build(|config: &GenesisConfig<T>| {457            // Modification of storage458            for (_num, _c) in &config.collection {459                <Module<T>>::init_collection(_c);460            }461462            for (_num, _c, _i) in &config.nft_item_id {463                <Module<T>>::init_nft_token(*_c, _i);464            }465466            for (collection_id, account_id, fungible_item) in &config.fungible_item_id {467                <Module<T>>::init_fungible_token(*collection_id, account_id, fungible_item);468            }469470            for (_num, _c, _i) in &config.refungible_item_id {471                <Module<T>>::init_refungible_token(*_c, _i);472            }473        })474    }475}476477decl_event!(478    pub enum Event<T>479    where480        AccountId = <T as system::Config>::AccountId,481    {482        /// New collection was created483        /// 484        /// # Arguments485        /// 486        /// * collection_id: Globally unique identifier of newly created collection.487        /// 488        /// * mode: [CollectionMode] converted into u8.489        /// 490        /// * account_id: Collection owner.491        Created(CollectionId, u8, AccountId),492493        /// New item was created.494        /// 495        /// # Arguments496        /// 497        /// * collection_id: Id of the collection where item was created.498        /// 499        /// * item_id: Id of an item. Unique within the collection.500        ///501        /// * recipient: Owner of newly created item 502        ItemCreated(CollectionId, TokenId, AccountId),503504        /// Collection item was burned.505        /// 506        /// # Arguments507        /// 508        /// collection_id.509        /// 510        /// item_id: Identifier of burned NFT.511        ItemDestroyed(CollectionId, TokenId),512513        /// Item was transferred514        ///515        /// * collection_id: Id of collection to which item is belong516        ///517        /// * item_id: Id of an item518        ///519        /// * sender: Original owner of item520        ///521        /// * recipient: New owner of item522        ///523        /// * amount: Always 1 for NFT524        Transfer(CollectionId, TokenId, AccountId, AccountId, u128),525    }526);527528decl_module! {529    pub struct Module<T: Config> for enum Call 530    where 531        origin: T::Origin532    {533        fn deposit_event() = default;534        type Error = Error<T>;535536        fn on_initialize(now: T::BlockNumber) -> Weight {537538            if ChainVersion::get() < 2539            {540                let value = NextCollectionID::get();541                CreatedCollectionCount::put(value);542                ChainVersion::put(2);543            }544545            0546        }547548        /// 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.549        /// 550        /// # Permissions551        /// 552        /// * Anyone.553        /// 554        /// # Arguments555        /// 556        /// * collection_name: UTF-16 string with collection name (limit 64 characters), will be stored as zero-terminated.557        /// 558        /// * collection_description: UTF-16 string with collection description (limit 256 characters), will be stored as zero-terminated.559        /// 560        /// * token_prefix: UTF-8 string with token prefix.561        /// 562        /// * mode: [CollectionMode] collection type and type dependent data.563        // returns collection ID564        #[weight = <T as Config>::WeightInfo::create_collection()]565        pub fn create_collection(origin,566                                 collection_name: Vec<u16>,567                                 collection_description: Vec<u16>,568                                 token_prefix: Vec<u8>,569                                 mode: CollectionMode) -> DispatchResult {570571            // Anyone can create a collection572            let who = ensure_signed(origin)?;573574            let decimal_points = match mode {575                CollectionMode::Fungible(points) => points,576                _ => 0577            };578579            let chain_limit = ChainLimit::get();580581            // bound Total number of collections582            ensure!(CollectionCount::get() < chain_limit.collection_numbers_limit, Error::<T>::TotalCollectionsLimitExceeded);583584            // check params585            ensure!(decimal_points <= MAX_DECIMAL_POINTS, Error::<T>::CollectionDecimalPointLimitExceeded);586            ensure!(collection_name.len() <= 64, Error::<T>::CollectionNameLimitExceeded);587            ensure!(collection_description.len() <= 256, Error::<T>::CollectionDescriptionLimitExceeded);588            ensure!(token_prefix.len() <= 16, Error::<T>::CollectionTokenPrefixLimitExceeded);589590            // Generate next collection ID591            let next_id = CreatedCollectionCount::get()592                .checked_add(1)593                .ok_or(Error::<T>::NumOverflow)?;594595            // bound counter596            let total = CollectionCount::get()597                .checked_add(1)598                .ok_or(Error::<T>::NumOverflow)?;599600            CreatedCollectionCount::put(next_id);601            CollectionCount::put(total);602603            let limits = CollectionLimits {604                sponsored_data_size: chain_limit.custom_data_limit,605                ..Default::default()606            };607608            // Create new collection609            let new_collection = CollectionType {610                owner: who.clone(),611                name: collection_name,612                mode: mode.clone(),613                mint_mode: false,614                access: AccessMode::Normal,615                description: collection_description,616                decimal_points: decimal_points,617                token_prefix: token_prefix,618                offchain_schema: Vec::new(),619                schema_version: SchemaVersion::ImageURL,620                sponsor: T::AccountId::default(),621                sponsor_confirmed: false,622                variable_on_chain_schema: Vec::new(),623                const_on_chain_schema: Vec::new(),624                limits,625            };626627            // Add new collection to map628            <Collection<T>>::insert(next_id, new_collection);629630            // call event631            Self::deposit_event(RawEvent::Created(next_id, mode.into(), who.clone()));632633            Ok(())634        }635636        /// **DANGEROUS**: Destroys collection and all NFTs within this collection. Users irrecoverably lose their assets and may lose real money.637        /// 638        /// # Permissions639        /// 640        /// * Collection Owner.641        /// 642        /// # Arguments643        /// 644        /// * collection_id: collection to destroy.645        #[weight = <T as Config>::WeightInfo::destroy_collection()]646        pub fn destroy_collection(origin, collection_id: CollectionId) -> DispatchResult {647648            let sender = ensure_signed(origin)?;649            Self::check_owner_permissions(collection_id, sender)?;650651            let target_collection = <Collection<T>>::get(collection_id);652            if !target_collection.limits.owner_can_destroy {653                fail!(Error::<T>::NoPermission);654            }655656            <AddressTokens<T>>::remove_prefix(collection_id);657            <Allowances<T>>::remove_prefix(collection_id);658            <Balance<T>>::remove_prefix(collection_id);659            <ItemListIndex>::remove(collection_id);660            <AdminList<T>>::remove(collection_id);661            <Collection<T>>::remove(collection_id);662            <WhiteList<T>>::remove_prefix(collection_id);663664            <NftItemList<T>>::remove_prefix(collection_id);665            <FungibleItemList<T>>::remove_prefix(collection_id);666            <ReFungibleItemList<T>>::remove_prefix(collection_id);667668            <NftTransferBasket<T>>::remove_prefix(collection_id);669            <FungibleTransferBasket<T>>::remove_prefix(collection_id);670            <ReFungibleTransferBasket<T>>::remove_prefix(collection_id);671672            if CollectionCount::get() > 0673            {674                // bound couter675                let total = CollectionCount::get()676                    .checked_sub(1)677                    .ok_or(Error::<T>::NumOverflow)?;678679                CollectionCount::put(total);680            }681682            Ok(())683        }684685        /// Add an address to white list.686        /// 687        /// # Permissions688        /// 689        /// * Collection Owner690        /// * Collection Admin691        /// 692        /// # Arguments693        /// 694        /// * collection_id.695        /// 696        /// * address.697        #[weight = <T as Config>::WeightInfo::add_to_white_list()]698        pub fn add_to_white_list(origin, collection_id: CollectionId, address: T::AccountId) -> DispatchResult{699700            let sender = ensure_signed(origin)?;701            Self::check_owner_or_admin_permissions(collection_id, sender)?;702703            <WhiteList<T>>::insert(collection_id, address, true);704            705            Ok(())706        }707708        /// Remove an address from white list.709        /// 710        /// # Permissions711        /// 712        /// * Collection Owner713        /// * Collection Admin714        /// 715        /// # Arguments716        /// 717        /// * collection_id.718        /// 719        /// * address.720        #[weight = <T as Config>::WeightInfo::remove_from_white_list()]721        pub fn remove_from_white_list(origin, collection_id: CollectionId, address: T::AccountId) -> DispatchResult{722723            let sender = ensure_signed(origin)?;724            Self::check_owner_or_admin_permissions(collection_id, sender)?;725726            <WhiteList<T>>::remove(collection_id, address);727728            Ok(())729        }730731        /// Toggle between normal and white list access for the methods with access for `Anyone`.732        /// 733        /// # Permissions734        /// 735        /// * Collection Owner.736        /// 737        /// # Arguments738        /// 739        /// * collection_id.740        /// 741        /// * mode: [AccessMode]742        #[weight = <T as Config>::WeightInfo::set_public_access_mode()]743        pub fn set_public_access_mode(origin, collection_id: CollectionId, mode: AccessMode) -> DispatchResult744        {745            let sender = ensure_signed(origin)?;746747            Self::check_owner_permissions(collection_id, sender)?;748            let mut target_collection = <Collection<T>>::get(collection_id);749            target_collection.access = mode;750            <Collection<T>>::insert(collection_id, target_collection);751752            Ok(())753        }754755        /// Allows Anyone to create tokens if:756        /// * White List is enabled, and757        /// * Address is added to white list, and758        /// * This method was called with True parameter759        /// 760        /// # Permissions761        /// * Collection Owner762        ///763        /// # Arguments764        /// 765        /// * collection_id.766        /// 767        /// * mint_permission: Boolean parameter. If True, allows minting to Anyone with conditions above.768        #[weight = <T as Config>::WeightInfo::set_mint_permission()]769        pub fn set_mint_permission(origin, collection_id: CollectionId, mint_permission: bool) -> DispatchResult770        {771            let sender = ensure_signed(origin)?;772773            Self::check_owner_permissions(collection_id, sender)?;774            let mut target_collection = <Collection<T>>::get(collection_id);775            target_collection.mint_mode = mint_permission;776            <Collection<T>>::insert(collection_id, target_collection);777778            Ok(())779        }780781        /// Change the owner of the collection.782        /// 783        /// # Permissions784        /// 785        /// * Collection Owner.786        /// 787        /// # Arguments788        /// 789        /// * collection_id.790        /// 791        /// * new_owner.792        #[weight = <T as Config>::WeightInfo::change_collection_owner()]793        pub fn change_collection_owner(origin, collection_id: CollectionId, new_owner: T::AccountId) -> DispatchResult {794795            let sender = ensure_signed(origin)?;796            Self::check_owner_permissions(collection_id, sender)?;797            let mut target_collection = <Collection<T>>::get(collection_id);798            target_collection.owner = new_owner;799            <Collection<T>>::insert(collection_id, target_collection);800801            Ok(())802        }803804        /// Adds an admin of the Collection.805        /// 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. 806        /// 807        /// # Permissions808        /// 809        /// * Collection Owner.810        /// * Collection Admin.811        /// 812        /// # Arguments813        /// 814        /// * collection_id: ID of the Collection to add admin for.815        /// 816        /// * new_admin_id: Address of new admin to add.817        #[weight = <T as Config>::WeightInfo::add_collection_admin()]818        pub fn add_collection_admin(origin, collection_id: CollectionId, new_admin_id: T::AccountId) -> DispatchResult {819820            let sender = ensure_signed(origin)?;821            Self::check_owner_or_admin_permissions(collection_id, sender)?;822            let mut admin_arr: Vec<T::AccountId> = Vec::new();823824            if <AdminList<T>>::contains_key(collection_id)825            {826                admin_arr = <AdminList<T>>::get(collection_id);827                ensure!(!admin_arr.contains(&new_admin_id), Error::<T>::AlreadyAdmin);828            }829830            // Number of collection admins831            ensure!((admin_arr.len() as u64) < ChainLimit::get().collections_admins_limit, Error::<T>::CollectionAdminsLimitExceeded);832833            admin_arr.push(new_admin_id);834            <AdminList<T>>::insert(collection_id, admin_arr);835836            Ok(())837        }838839        /// 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.840        ///841        /// # Permissions842        /// 843        /// * Collection Owner.844        /// * Collection Admin.845        /// 846        /// # Arguments847        /// 848        /// * collection_id: ID of the Collection to remove admin for.849        /// 850        /// * account_id: Address of admin to remove.851        #[weight = <T as Config>::WeightInfo::remove_collection_admin()]852        pub fn remove_collection_admin(origin, collection_id: CollectionId, account_id: T::AccountId) -> DispatchResult {853854            let sender = ensure_signed(origin)?;855            Self::check_owner_or_admin_permissions(collection_id, sender)?;856            ensure!(<AdminList<T>>::contains_key(collection_id), Error::<T>::AdminNotFound);857858            let mut admin_arr = <AdminList<T>>::get(collection_id);859            admin_arr.retain(|i| *i != account_id);860            <AdminList<T>>::insert(collection_id, admin_arr);861862            Ok(())863        }864865        /// # Permissions866        /// 867        /// * Collection Owner868        /// 869        /// # Arguments870        /// 871        /// * collection_id.872        /// 873        /// * new_sponsor.874        #[weight = <T as Config>::WeightInfo::set_collection_sponsor()]875        pub fn set_collection_sponsor(origin, collection_id: CollectionId, new_sponsor: T::AccountId) -> DispatchResult {876877            let sender = ensure_signed(origin)?;878            ensure!(<Collection<T>>::contains_key(collection_id), Error::<T>::CollectionNotFound);879880            let mut target_collection = <Collection<T>>::get(collection_id);881            ensure!(sender == target_collection.owner, Error::<T>::NoPermission);882883            target_collection.sponsor = new_sponsor;884            target_collection.sponsor_confirmed = false;885            <Collection<T>>::insert(collection_id, target_collection);886887            Ok(())888        }889890        /// # Permissions891        /// 892        /// * Sponsor.893        /// 894        /// # Arguments895        /// 896        /// * collection_id.897        #[weight = <T as Config>::WeightInfo::confirm_sponsorship()]898        pub fn confirm_sponsorship(origin, collection_id: CollectionId) -> DispatchResult {899900            let sender = ensure_signed(origin)?;901            ensure!(<Collection<T>>::contains_key(collection_id), Error::<T>::CollectionNotFound);902903            let mut target_collection = <Collection<T>>::get(collection_id);904            ensure!(sender == target_collection.sponsor, Error::<T>::ConfirmUnsetSponsorFail);905906            target_collection.sponsor_confirmed = true;907            <Collection<T>>::insert(collection_id, target_collection);908909            Ok(())910        }911912        /// Switch back to pay-per-own-transaction model.913        ///914        /// # Permissions915        ///916        /// * Collection owner.917        /// 918        /// # Arguments919        /// 920        /// * collection_id.921        #[weight = <T as Config>::WeightInfo::remove_collection_sponsor()]922        pub fn remove_collection_sponsor(origin, collection_id: CollectionId) -> DispatchResult {923924            let sender = ensure_signed(origin)?;925            ensure!(<Collection<T>>::contains_key(collection_id), Error::<T>::CollectionNotFound);926927            let mut target_collection = <Collection<T>>::get(collection_id);928            ensure!(sender == target_collection.owner, Error::<T>::NoPermission);929930            target_collection.sponsor = T::AccountId::default();931            target_collection.sponsor_confirmed = false;932            <Collection<T>>::insert(collection_id, target_collection);933934            Ok(())935        }936937        /// This method creates a concrete instance of NFT Collection created with CreateCollection method.938        /// 939        /// # Permissions940        /// 941        /// * Collection Owner.942        /// * Collection Admin.943        /// * Anyone if944        ///     * White List is enabled, and945        ///     * Address is added to white list, and946        ///     * MintPermission is enabled (see SetMintPermission method)947        /// 948        /// # Arguments949        /// 950        /// * collection_id: ID of the collection.951        /// 952        /// * owner: Address, initial owner of the NFT.953        ///954        /// * data: Token data to store on chain.955        // #[weight =956        // (130_000_000 as Weight)957        // .saturating_add((2135 as Weight).saturating_mul((properties.len() as u64) as Weight))958        // .saturating_add(RocksDbWeight::get().reads(10 as Weight))959        // .saturating_add(RocksDbWeight::get().writes(8 as Weight))]960961        #[weight = <T as Config>::WeightInfo::create_item(data.len())]962        pub fn create_item(origin, collection_id: CollectionId, owner: T::AccountId, data: CreateItemData) -> DispatchResult {963964            let sender = ensure_signed(origin)?;965966            Self::collection_exists(collection_id)?;967968            let target_collection = <Collection<T>>::get(collection_id);969970            Self::can_create_items_in_collection(collection_id, &target_collection, &sender, &owner, 1)?;971            Self::validate_create_item_args(&target_collection, &data)?;972            Self::create_item_no_validation(collection_id, owner, data)?;973974            Ok(())975        }976977        /// This method creates multiple instances of NFT Collection created with CreateCollection method.978        /// 979        /// # Permissions980        /// 981        /// * Collection Owner.982        /// * Collection Admin.983        /// * Anyone if984        ///     * White List is enabled, and985        ///     * Address is added to white list, and986        ///     * MintPermission is enabled (see SetMintPermission method)987        /// 988        /// # Arguments989        /// 990        /// * collection_id: ID of the collection.991        /// 992        /// * itemsData: Array items properties. Each property is an array of bytes itself, see [create_item].993        /// 994        /// * owner: Address, initial owner of the NFT.995        #[weight = <T as Config>::WeightInfo::create_item(items_data.into_iter()996                               .map(|data| { data.len() })997                               .sum())]998        pub fn create_multiple_items(origin, collection_id: CollectionId, owner: T::AccountId, items_data: Vec<CreateItemData>) -> DispatchResult {9991000            ensure!(items_data.len() > 0, Error::<T>::EmptyArgument);1001            let sender = ensure_signed(origin)?;10021003            Self::collection_exists(collection_id)?;1004            let target_collection = <Collection<T>>::get(collection_id);10051006            Self::can_create_items_in_collection(collection_id, &target_collection, &sender, &owner, items_data.len() as u32)?;10071008            for data in &items_data {1009                Self::validate_create_item_args(&target_collection, data)?;1010            }1011            for data in &items_data {1012                Self::create_item_no_validation(collection_id, owner.clone(), data.clone())?;1013            }10141015            Ok(())1016        }10171018        /// Destroys a concrete instance of NFT.1019        /// 1020        /// # Permissions1021        /// 1022        /// * Collection Owner.1023        /// * Collection Admin.1024        /// * Current NFT Owner.1025        /// 1026        /// # Arguments1027        /// 1028        /// * collection_id: ID of the collection.1029        /// 1030        /// * item_id: ID of NFT to burn.1031        #[weight = <T as Config>::WeightInfo::burn_item()]1032        pub fn burn_item(origin, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {10331034            let sender = ensure_signed(origin)?;1035            Self::collection_exists(collection_id)?;10361037            // Transfer permissions check1038            let target_collection = <Collection<T>>::get(collection_id);1039            ensure!(1040                Self::is_item_owner(sender.clone(), collection_id, item_id) ||1041                (1042                    target_collection.limits.owner_can_transfer &&1043                    Self::is_owner_or_admin_permissions(collection_id, sender.clone())1044                ),1045                Error::<T>::NoPermission1046            );10471048            if target_collection.access == AccessMode::WhiteList {1049                Self::check_white_list(collection_id, &sender)?;1050            }10511052            match target_collection.mode1053            {1054                CollectionMode::NFT => Self::burn_nft_item(collection_id, item_id)?,1055                CollectionMode::Fungible(_)  => Self::burn_fungible_item(&sender, collection_id, value)?,1056                CollectionMode::ReFungible  => Self::burn_refungible_item(collection_id, item_id, &sender)?,1057                _ => ()1058            };10591060            // call event1061            Self::deposit_event(RawEvent::ItemDestroyed(collection_id, item_id));10621063            Ok(())1064        }10651066        /// Change ownership of the token.1067        /// 1068        /// # Permissions1069        /// 1070        /// * Collection Owner1071        /// * Collection Admin1072        /// * Current NFT owner1073        ///1074        /// # Arguments1075        /// 1076        /// * recipient: Address of token recipient.1077        /// 1078        /// * collection_id.1079        /// 1080        /// * item_id: ID of the item1081        ///     * Non-Fungible Mode: Required.1082        ///     * Fungible Mode: Ignored.1083        ///     * Re-Fungible Mode: Required.1084        /// 1085        /// * value: Amount to transfer.1086        ///     * Non-Fungible Mode: Ignored1087        ///     * Fungible Mode: Must specify transferred amount1088        ///     * Re-Fungible Mode: Must specify transferred portion (between 0 and 1)1089        #[weight = <T as Config>::WeightInfo::transfer()]1090        pub fn transfer(origin, recipient: T::AccountId, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {1091            let sender = ensure_signed(origin)?;1092            Self::transfer_internal(sender, recipient, collection_id, item_id, value)1093        }10941095        /// Set, change, or remove approved address to transfer the ownership of the NFT.1096        /// 1097        /// # Permissions1098        /// 1099        /// * Collection Owner1100        /// * Collection Admin1101        /// * Current NFT owner1102        /// 1103        /// # Arguments1104        /// 1105        /// * approved: Address that is approved to transfer this NFT or zero (if needed to remove approval).1106        /// 1107        /// * collection_id.1108        /// 1109        /// * item_id: ID of the item.1110        #[weight = <T as Config>::WeightInfo::approve()]1111        pub fn approve(origin, spender: T::AccountId, collection_id: CollectionId, item_id: TokenId, amount: u128) -> DispatchResult {11121113            let sender = ensure_signed(origin)?;11141115            Self::collection_exists(collection_id)?;1116            Self::token_exists(collection_id, item_id, &sender)?;11171118            // Transfer permissions check1119            let target_collection = <Collection<T>>::get(collection_id);1120            let allowance_limit = if target_collection.limits.owner_can_transfer &&1121                Self::is_owner_or_admin_permissions(1122                    collection_id,1123                    sender.clone(),1124                ) {1125                None1126            } else if let Some(amount) = Self::owned_amount(1127                sender.clone(),1128                collection_id,1129                item_id,1130            ) {1131                Some(amount)1132            } else {1133                fail!(Error::<T>::NoPermission);1134            };11351136            if target_collection.access == AccessMode::WhiteList {1137                Self::check_white_list(collection_id, &sender)?;1138                Self::check_white_list(collection_id, &spender)?;1139            }11401141            let allowance_exists = <Allowances<T>>::contains_key(collection_id, (item_id, &sender, &spender));1142            let mut allowance: u128 = amount;1143            if allowance_exists {1144                allowance += <Allowances<T>>::get(collection_id, (item_id, &sender, &spender));1145            }1146            if let Some(limit) = allowance_limit {1147                ensure!(limit >= allowance, Error::<T>::TokenValueTooLow);1148            }1149            <Allowances<T>>::insert(collection_id, (item_id, sender.clone(), spender.clone()), allowance);11501151            Ok(())1152        }1153        1154        /// 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.1155        /// 1156        /// # Permissions1157        /// * Collection Owner1158        /// * Collection Admin1159        /// * Current NFT owner1160        /// * Address approved by current NFT owner1161        /// 1162        /// # Arguments1163        /// 1164        /// * from: Address that owns token.1165        /// 1166        /// * recipient: Address of token recipient.1167        /// 1168        /// * collection_id.1169        /// 1170        /// * item_id: ID of the item.1171        /// 1172        /// * value: Amount to transfer.1173        #[weight = <T as Config>::WeightInfo::transfer_from()]1174        pub fn transfer_from(origin, from: T::AccountId, recipient: T::AccountId, collection_id: CollectionId, item_id: TokenId, value: u128 ) -> DispatchResult {11751176            let sender = ensure_signed(origin)?;1177            let mut appoved_transfer = false;11781179            // Check approval1180            let mut approval: u128 = 0;1181            if <Allowances<T>>::contains_key(collection_id, (item_id, &from, &sender)) {1182                approval = <Allowances<T>>::get(collection_id, (item_id, &from, &sender));1183                ensure!(approval >= value, Error::<T>::TokenValueNotEnough);1184                appoved_transfer = true;1185            }11861187            let target_collection = <Collection<T>>::get(collection_id);11881189            // Limits check1190            Self::is_correct_transfer(collection_id, &target_collection, &recipient)?;11911192            // Transfer permissions check         1193            ensure!(1194                appoved_transfer || 1195                (1196                    target_collection.limits.owner_can_transfer &&1197                    Self::is_owner_or_admin_permissions(collection_id, sender.clone())1198                ),1199                Error::<T>::NoPermission1200            );12011202            if target_collection.access == AccessMode::WhiteList {1203                Self::check_white_list(collection_id, &sender)?;1204                Self::check_white_list(collection_id, &recipient)?;1205            }12061207            // Reduce approval by transferred amount or remove if remaining approval drops to 01208            if approval.checked_sub(value).unwrap_or(0) > 0 {1209                <Allowances<T>>::insert(collection_id, (item_id, &from, &sender), approval - value);1210            }1211            else {1212                <Allowances<T>>::remove(collection_id, (item_id, &from, &sender));1213            }12141215            match target_collection.mode1216            {1217                CollectionMode::NFT => Self::transfer_nft(collection_id, item_id, from, recipient)?,1218                CollectionMode::Fungible(_)  => Self::transfer_fungible(collection_id, value, &from, &recipient)?,1219                CollectionMode::ReFungible  => Self::transfer_refungible(collection_id, item_id, value, from.clone(), recipient)?,1220                _ => ()1221            };12221223            Ok(())1224        }12251226        // #[weight = 0]1227        // pub fn safe_transfer_from(origin, collection_id: CollectionId, item_id: TokenId, new_owner: T::AccountId) -> DispatchResult {12281229        //     // let no_perm_mes = "You do not have permissions to modify this collection";1230        //     // ensure!(<ApprovedList<T>>::contains_key((collection_id, item_id)), no_perm_mes);1231        //     // let list_itm = <ApprovedList<T>>::get((collection_id, item_id));1232        //     // ensure!(list_itm.contains(&new_owner.clone()), no_perm_mes);12331234        //     // // on_nft_received  call12351236        //     // Self::transfer(origin, collection_id, item_id, new_owner)?;12371238        //     Ok(())1239        // }12401241        /// Set off-chain data schema.1242        /// 1243        /// # Permissions1244        /// 1245        /// * Collection Owner1246        /// * Collection Admin1247        /// 1248        /// # Arguments1249        /// 1250        /// * collection_id.1251        /// 1252        /// * schema: String representing the offchain data schema.1253        #[weight = <T as Config>::WeightInfo::set_variable_meta_data()]1254        pub fn set_variable_meta_data (1255            origin,1256            collection_id: CollectionId,1257            item_id: TokenId,1258            data: Vec<u8>1259        ) -> DispatchResult {1260            let sender = ensure_signed(origin)?;1261            1262            Self::collection_exists(collection_id)?;1263            Self::token_exists(collection_id, item_id, &sender)?;12641265            ensure!(ChainLimit::get().custom_data_limit >= data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);12661267            // Modify permissions check1268            let target_collection = <Collection<T>>::get(collection_id);1269            ensure!(Self::is_item_owner(sender.clone(), collection_id, item_id) ||1270                Self::is_owner_or_admin_permissions(collection_id, sender.clone()),1271                Error::<T>::NoPermission);12721273            match target_collection.mode1274            {1275                CollectionMode::NFT => Self::set_nft_variable_data(collection_id, item_id, data)?,1276                CollectionMode::ReFungible  => Self::set_re_fungible_variable_data(collection_id, item_id, data)?,1277                CollectionMode::Fungible(_) => fail!(Error::<T>::CantStoreMetadataInFungibleTokens),1278                _ => fail!(Error::<T>::UnexpectedCollectionType)1279            };12801281            Ok(())1282        }1283 1284        /// Set schema standard1285        /// ImageURL1286        /// Unique1287        /// 1288        /// # Permissions1289        /// 1290        /// * Collection Owner1291        /// * Collection Admin1292        /// 1293        /// # Arguments1294        /// 1295        /// * collection_id.1296        /// 1297        /// * schema: SchemaVersion: enum1298        #[weight = <T as Config>::WeightInfo::set_schema_version()]1299        pub fn set_schema_version(1300            origin,1301            collection_id: CollectionId,1302            version: SchemaVersion1303        ) -> DispatchResult {1304            let sender = ensure_signed(origin)?;1305            Self::check_owner_or_admin_permissions(collection_id, sender.clone())?;1306            let mut target_collection = <Collection<T>>::get(collection_id);1307            target_collection.schema_version = version;1308            <Collection<T>>::insert(collection_id, target_collection);13091310            Ok(())1311        }13121313        /// Set off-chain data schema.1314        /// 1315        /// # Permissions1316        /// 1317        /// * Collection Owner1318        /// * Collection Admin1319        /// 1320        /// # Arguments1321        /// 1322        /// * collection_id.1323        /// 1324        /// * schema: String representing the offchain data schema.1325        #[weight = <T as Config>::WeightInfo::set_offchain_schema()]1326        pub fn set_offchain_schema(1327            origin,1328            collection_id: CollectionId,1329            schema: Vec<u8>1330        ) -> DispatchResult {1331            let sender = ensure_signed(origin)?;1332            Self::check_owner_or_admin_permissions(collection_id, sender.clone())?;13331334            // check schema limit1335            ensure!(schema.len() as u32 <= ChainLimit::get().offchain_schema_limit, "");13361337            let mut target_collection = <Collection<T>>::get(collection_id);1338            target_collection.offchain_schema = schema;1339            <Collection<T>>::insert(collection_id, target_collection);13401341            Ok(())1342        }13431344        /// Set const on-chain data schema.1345        /// 1346        /// # Permissions1347        /// 1348        /// * Collection Owner1349        /// * Collection Admin1350        /// 1351        /// # Arguments1352        /// 1353        /// * collection_id.1354        /// 1355        /// * schema: String representing the const on-chain data schema.1356        #[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1357        pub fn set_const_on_chain_schema (1358            origin,1359            collection_id: CollectionId,1360            schema: Vec<u8>1361        ) -> DispatchResult {1362            let sender = ensure_signed(origin)?;1363            Self::check_owner_or_admin_permissions(collection_id, sender.clone())?;13641365            // check schema limit1366            ensure!(schema.len() as u32 <= ChainLimit::get().const_on_chain_schema_limit, "");13671368            let mut target_collection = <Collection<T>>::get(collection_id);1369            target_collection.const_on_chain_schema = schema;1370            <Collection<T>>::insert(collection_id, target_collection);13711372            Ok(())1373        }13741375        /// Set variable on-chain data schema.1376        /// 1377        /// # Permissions1378        /// 1379        /// * Collection Owner1380        /// * Collection Admin1381        /// 1382        /// # Arguments1383        /// 1384        /// * collection_id.1385        /// 1386        /// * schema: String representing the variable on-chain data schema.1387        #[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1388        pub fn set_variable_on_chain_schema (1389            origin,1390            collection_id: CollectionId,1391            schema: Vec<u8>1392        ) -> DispatchResult {1393            let sender = ensure_signed(origin)?;1394            Self::check_owner_or_admin_permissions(collection_id, sender.clone())?;13951396            // check schema limit1397            ensure!(schema.len() as u32 <= ChainLimit::get().variable_on_chain_schema_limit, "");13981399            let mut target_collection = <Collection<T>>::get(collection_id);1400            target_collection.variable_on_chain_schema = schema;1401            <Collection<T>>::insert(collection_id, target_collection);14021403            Ok(())1404        }14051406        // Sudo permissions function1407        #[weight = <T as Config>::WeightInfo::set_chain_limits()]1408        pub fn set_chain_limits(1409            origin,1410            limits: ChainLimits1411        ) -> DispatchResult {14121413            #[cfg(not(feature = "runtime-benchmarks"))]1414            ensure_root(origin)?;14151416            <ChainLimit>::put(limits);1417            Ok(())1418        }14191420        /// Enable smart contract self-sponsoring.1421        /// 1422        /// # Permissions1423        /// 1424        /// * Contract Owner1425        /// 1426        /// # Arguments1427        /// 1428        /// * contract address1429        /// * enable flag1430        /// 1431        #[weight = <T as Config>::WeightInfo::enable_contract_sponsoring()]1432        pub fn enable_contract_sponsoring(1433            origin,1434            contract_address: T::AccountId,1435            enable: bool1436        ) -> DispatchResult {14371438            let sender = ensure_signed(origin)?;14391440            #[cfg(feature = "runtime-benchmarks")]1441            <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());14421443            Self::ensure_contract_owned(sender, &contract_address)?;14441445            <ContractSelfSponsoring<T>>::insert(contract_address, enable);1446            Ok(())1447        }14481449        /// Set the rate limit for contract sponsoring to specified number of blocks.1450        /// 1451        /// If not set (has the default value of 0 blocks), the sponsoring will be disabled. 1452        /// If set to the number B (for blocks), the transactions will be sponsored with a rate 1453        /// limit of B, i.e. fees for every transaction sent to this smart contract will be paid 1454        /// from contract endowment if there are at least B blocks between such transactions. 1455        /// Nonetheless, if transactions are sent more frequently, the fees are paid by the sender.1456        /// 1457        /// # Permissions1458        /// 1459        /// * Contract Owner1460        /// 1461        /// # Arguments1462        /// 1463        /// -`contract_address`: Address of the contract to sponsor1464        /// -`rate_limit`: Number of blocks to wait until the next sponsored transaction is allowed1465        /// 1466        #[weight = <T as Config>::WeightInfo::set_contract_sponsoring_rate_limit()]1467        pub fn set_contract_sponsoring_rate_limit(1468            origin,1469            contract_address: T::AccountId,1470            rate_limit: T::BlockNumber1471        ) -> DispatchResult {1472            let sender = ensure_signed(origin)?;14731474            #[cfg(feature = "runtime-benchmarks")]1475            <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());14761477            Self::ensure_contract_owned(sender, &contract_address)?;1478            <ContractSponsoringRateLimit<T>>::insert(contract_address, rate_limit);1479            Ok(())1480        }14811482        /// Enable the white list for a contract. Only addresses added to the white list with addToContractWhiteList will be able to call this smart contract.1483        /// 1484        /// # Permissions1485        /// 1486        /// * Address that deployed smart contract.1487        /// 1488        /// # Arguments1489        /// 1490        /// -`contract_address`: Address of the contract.1491        /// 1492        /// - `enable`: .  1493        #[weight = <T as Config>::WeightInfo::toggle_contract_white_list()]1494        pub fn toggle_contract_white_list(1495            origin,1496            contract_address: T::AccountId,1497            enable: bool1498        ) -> DispatchResult {1499            let sender = ensure_signed(origin)?;15001501            #[cfg(feature = "runtime-benchmarks")]1502            <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());15031504            Self::ensure_contract_owned(sender, &contract_address)?;1505            <ContractWhiteListEnabled<T>>::insert(contract_address, enable);1506            Ok(())1507        }1508        1509        /// Add an address to smart contract white list.1510        /// 1511        /// # Permissions1512        /// 1513        /// * Address that deployed smart contract.1514        /// 1515        /// # Arguments1516        /// 1517        /// -`contract_address`: Address of the contract.1518        ///1519        /// -`account_address`: Address to add.1520        #[weight = <T as Config>::WeightInfo::add_to_contract_white_list()]1521        pub fn add_to_contract_white_list(1522            origin,1523            contract_address: T::AccountId,1524            account_address: T::AccountId1525        ) -> DispatchResult {1526            let sender = ensure_signed(origin)?;15271528            #[cfg(feature = "runtime-benchmarks")]1529            <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());1530            1531            Self::ensure_contract_owned(sender, &contract_address)?;      1532            <ContractWhiteList<T>>::insert(contract_address, account_address, true);1533            Ok(())1534        }15351536        /// Remove an address from smart contract white list.1537        /// 1538        /// # Permissions1539        /// 1540        /// * Address that deployed smart contract.1541        /// 1542        /// # Arguments1543        /// 1544        /// -`contract_address`: Address of the contract.1545        ///1546        /// -`account_address`: Address to remove.1547        #[weight = <T as Config>::WeightInfo::remove_from_contract_white_list()]1548        pub fn remove_from_contract_white_list(1549            origin,1550            contract_address: T::AccountId,1551            account_address: T::AccountId1552        ) -> DispatchResult {1553            let sender = ensure_signed(origin)?;15541555            #[cfg(feature = "runtime-benchmarks")]1556            <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());15571558            Self::ensure_contract_owned(sender, &contract_address)?;1559            <ContractWhiteList<T>>::remove(contract_address, account_address);1560            Ok(())1561        }15621563        #[weight = <T as Config>::WeightInfo::set_collection_limits()]1564        pub fn set_collection_limits(1565            origin,1566            collection_id: u32,1567            new_limits: CollectionLimits,1568        ) -> DispatchResult {1569            let sender = ensure_signed(origin)?;1570            Self::check_owner_permissions(collection_id, sender.clone())?;1571            let mut target_collection = <Collection<T>>::get(collection_id);1572            let old_limits = target_collection.limits;1573            let chain_limits = ChainLimit::get();15741575            // collection bounds1576            ensure!(new_limits.sponsor_transfer_timeout <= MAX_SPONSOR_TIMEOUT &&1577                new_limits.account_token_ownership_limit <= MAX_TOKEN_OWNERSHIP && 1578                new_limits.sponsored_data_size <= chain_limits.custom_data_limit,1579                Error::<T>::CollectionLimitBoundsExceeded);15801581            // token_limit   check  prev1582            ensure!(old_limits.token_limit >= new_limits.token_limit, Error::<T>::CollectionTokenLimitExceeded);1583            ensure!(new_limits.token_limit > 0, Error::<T>::CollectionTokenLimitExceeded);15841585            ensure!(1586                (old_limits.owner_can_transfer || !new_limits.owner_can_transfer) &&1587                (old_limits.owner_can_destroy || !new_limits.owner_can_destroy),1588                Error::<T>::OwnerPermissionsCantBeReverted,1589            );15901591            target_collection.limits = new_limits;1592            <Collection<T>>::insert(collection_id, target_collection);15931594            Ok(())1595        } 1596    }1597}15981599impl<T: Config> Module<T> {16001601    pub fn transfer_internal(sender: T::AccountId, recipient: T::AccountId, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {16021603        let target_collection = <Collection<T>>::get(collection_id);16041605        // Limits check1606        Self::is_correct_transfer(collection_id, &target_collection, &recipient)?;16071608        // Transfer permissions check1609        ensure!(Self::is_item_owner(sender.clone(), collection_id, item_id) ||1610            Self::is_owner_or_admin_permissions(collection_id, sender.clone()),1611            Error::<T>::NoPermission);16121613        if target_collection.access == AccessMode::WhiteList {1614            Self::check_white_list(collection_id, &sender)?;1615            Self::check_white_list(collection_id, &recipient)?;1616        }16171618        match target_collection.mode1619        {1620            CollectionMode::NFT => Self::transfer_nft(collection_id, item_id, sender.clone(), recipient.clone())?,1621            CollectionMode::Fungible(_)  => Self::transfer_fungible(collection_id, value, &sender, &recipient)?,1622            CollectionMode::ReFungible  => Self::transfer_refungible(collection_id, item_id, value, sender.clone(), recipient.clone())?,1623            _ => ()1624        };16251626        Self::deposit_event(RawEvent::Transfer(collection_id, item_id, sender, recipient, value));16271628        Ok(())1629    }163016311632    fn is_correct_transfer(collection_id: CollectionId, collection: &CollectionType<T::AccountId>, recipient: &T::AccountId) -> DispatchResult {16331634        // check token limit and account token limit1635        let account_items: u32 = <AddressTokens<T>>::get(collection_id, recipient).len() as u32;1636        ensure!(collection.limits.account_token_ownership_limit > account_items,  Error::<T>::AccountTokenLimitExceeded);1637        1638        Ok(())1639    }16401641    fn can_create_items_in_collection(collection_id: CollectionId, collection: &CollectionType<T::AccountId>, sender: &T::AccountId, owner: &T::AccountId, amount: u32) -> DispatchResult {16421643        // check token limit and account token limit1644        let total_items: u32 = ItemListIndex::get(collection_id)1645            .checked_add(amount)1646            .ok_or(Error::<T>::CollectionTokenLimitExceeded)?;1647        let account_items: u32 = (<AddressTokens<T>>::get(collection_id, owner).len() as u32)1648            .checked_add(amount)1649            .ok_or(Error::<T>::AccountTokenLimitExceeded)?;1650        ensure!(collection.limits.token_limit >= total_items,  Error::<T>::CollectionTokenLimitExceeded);1651        ensure!(collection.limits.account_token_ownership_limit >= account_items,  Error::<T>::AccountTokenLimitExceeded);16521653        if !Self::is_owner_or_admin_permissions(collection_id, sender.clone()) {1654            ensure!(collection.mint_mode == true, Error::<T>::PublicMintingNotAllowed);1655            Self::check_white_list(collection_id, owner)?;1656            Self::check_white_list(collection_id, sender)?;1657        }16581659        Ok(())1660    }16611662    fn validate_create_item_args(target_collection: &CollectionType<T::AccountId>, data: &CreateItemData) -> DispatchResult {1663        match target_collection.mode1664        {1665            CollectionMode::NFT => {1666                if let CreateItemData::NFT(data) = data {1667                    // check sizes1668                    ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, Error::<T>::TokenConstDataLimitExceeded);1669                    ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);1670                } else {1671                    fail!(Error::<T>::NotNftDataUsedToMintNftCollectionToken);1672                }1673            },1674            CollectionMode::Fungible(_) => {1675                if let CreateItemData::Fungible(_) = data {1676                } else {1677                    fail!(Error::<T>::NotFungibleDataUsedToMintFungibleCollectionToken);1678                }1679            },1680            CollectionMode::ReFungible => {1681                if let CreateItemData::ReFungible(data) = data {16821683                    // check sizes1684                    ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, Error::<T>::TokenConstDataLimitExceeded);1685                    ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);16861687                    // Check refungibility limits1688                    ensure!(data.pieces <= MAX_REFUNGIBLE_PIECES, Error::<T>::WrongRefungiblePieces);1689                    ensure!(data.pieces > 0, Error::<T>::WrongRefungiblePieces);1690                } else {1691                    fail!(Error::<T>::NotReFungibleDataUsedToMintReFungibleCollectionToken);1692                }1693            },1694            _ => { fail!(Error::<T>::UnexpectedCollectionType); }1695        };16961697        Ok(())1698    }16991700    fn create_item_no_validation(collection_id: CollectionId, owner: T::AccountId, data: CreateItemData) -> DispatchResult {1701        match data1702        {1703            CreateItemData::NFT(data) => {1704                let item = NftItemType {1705                    owner: owner.clone(),1706                    const_data: data.const_data,1707                    variable_data: data.variable_data1708                };17091710                Self::add_nft_item(collection_id, item)?;1711            },1712            CreateItemData::Fungible(data) => {1713                Self::add_fungible_item(collection_id, &owner, data.value)?;1714            },1715            CreateItemData::ReFungible(data) => {1716                let mut owner_list = Vec::new();1717                owner_list.push(Ownership {owner: owner.clone(), fraction: data.pieces});17181719                let item = ReFungibleItemType {1720                    owner: owner_list,1721                    const_data: data.const_data,1722                    variable_data: data.variable_data1723                };17241725                Self::add_refungible_item(collection_id, item)?;1726            }1727        };17281729        // call event1730        Self::deposit_event(RawEvent::ItemCreated(collection_id, <ItemListIndex>::get(collection_id), owner));17311732        Ok(())1733    }17341735    fn add_fungible_item(collection_id: CollectionId, owner: &T::AccountId, value: u128) -> DispatchResult {17361737        // Does new owner already have an account?1738        let mut balance: u128 = 0;1739        if <FungibleItemList<T>>::contains_key(collection_id, owner) {1740            balance = <FungibleItemList<T>>::get(collection_id, owner).value;1741        } 17421743        // Mint 1744        let item = FungibleItemType {1745            value: balance + value1746        };1747        <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), item);17481749        // Update balance1750        let new_balance = <Balance<T>>::get(collection_id, owner)1751            .checked_add(value)1752            .ok_or(Error::<T>::NumOverflow)?;1753        <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);17541755        Ok(())1756    }17571758    fn add_refungible_item(collection_id: CollectionId, item: ReFungibleItemType<T::AccountId>) -> DispatchResult {1759        let current_index = <ItemListIndex>::get(collection_id)1760            .checked_add(1)1761            .ok_or(Error::<T>::NumOverflow)?;1762        let itemcopy = item.clone();17631764        let value = item.owner.first().unwrap().fraction;1765        let owner = item.owner.first().unwrap().owner.clone();17661767        Self::add_token_index(collection_id, current_index, &owner)?;17681769        <ItemListIndex>::insert(collection_id, current_index);1770        <ReFungibleItemList<T>>::insert(collection_id, current_index, itemcopy);17711772        // Update balance1773        let new_balance = <Balance<T>>::get(collection_id, &owner)1774            .checked_add(value)1775            .ok_or(Error::<T>::NumOverflow)?;1776        <Balance<T>>::insert(collection_id, owner.clone(), new_balance);17771778        Ok(())1779    }17801781    fn add_nft_item(collection_id: CollectionId, item: NftItemType<T::AccountId>) -> DispatchResult {1782        let current_index = <ItemListIndex>::get(collection_id)1783            .checked_add(1)1784            .ok_or(Error::<T>::NumOverflow)?;17851786        let item_owner = item.owner.clone();1787        Self::add_token_index(collection_id, current_index, &item.owner)?;17881789        <ItemListIndex>::insert(collection_id, current_index);1790        <NftItemList<T>>::insert(collection_id, current_index, item);17911792        // Update balance1793        let new_balance = <Balance<T>>::get(collection_id, item_owner.clone())1794            .checked_add(1)1795            .ok_or(Error::<T>::NumOverflow)?;1796        <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);17971798        Ok(())1799    }18001801    fn burn_refungible_item(1802        collection_id: CollectionId,1803        item_id: TokenId,1804        owner: &T::AccountId,1805    ) -> DispatchResult {1806        ensure!(1807            <ReFungibleItemList<T>>::contains_key(collection_id, item_id),1808            Error::<T>::TokenNotFound1809        );1810        let mut token = <ReFungibleItemList<T>>::get(collection_id, item_id);1811        let rft_balance = token1812            .owner1813            .iter()1814            .filter(|&i| i.owner == *owner)1815            .next()1816            .unwrap();1817        Self::remove_token_index(collection_id, item_id, owner)?;18181819        // update balance1820        let new_balance = <Balance<T>>::get(collection_id, rft_balance.owner.clone())1821            .checked_sub(rft_balance.fraction)1822            .ok_or(Error::<T>::NumOverflow)?;1823        <Balance<T>>::insert(collection_id, rft_balance.owner.clone(), new_balance);18241825        // Re-create owners list with sender removed1826        let index = token1827            .owner1828            .iter()1829            .position(|i| i.owner == *owner)1830            .unwrap();1831        token.owner.remove(index);1832        let owner_count = token.owner.len();18331834        // Burn the token completely if this was the last (only) owner1835        if owner_count == 0 {1836            <ReFungibleItemList<T>>::remove(collection_id, item_id);1837        }1838        else {1839            <ReFungibleItemList<T>>::insert(collection_id, item_id, token);1840        }18411842        Ok(())1843    }18441845    fn burn_nft_item(collection_id: CollectionId, item_id: TokenId) -> DispatchResult {1846        ensure!(1847            <NftItemList<T>>::contains_key(collection_id, item_id),1848            Error::<T>::TokenNotFound1849        );1850        let item = <NftItemList<T>>::get(collection_id, item_id);1851        Self::remove_token_index(collection_id, item_id, &item.owner)?;18521853        // update balance1854        let new_balance = <Balance<T>>::get(collection_id, &item.owner)1855            .checked_sub(1)1856            .ok_or(Error::<T>::NumOverflow)?;1857        <Balance<T>>::insert(collection_id, item.owner.clone(), new_balance);1858        <NftItemList<T>>::remove(collection_id, item_id);18591860        Ok(())1861    }18621863    fn burn_fungible_item(owner: &T::AccountId, collection_id: CollectionId, value: u128) -> DispatchResult {1864        ensure!(1865            <FungibleItemList<T>>::contains_key(collection_id, owner),1866            Error::<T>::TokenNotFound1867        );1868        let mut balance = <FungibleItemList<T>>::get(collection_id, owner);1869        ensure!(balance.value >= value, Error::<T>::TokenValueNotEnough);18701871        // update balance1872        let new_balance = <Balance<T>>::get(collection_id, owner)1873            .checked_sub(value)1874            .ok_or(Error::<T>::NumOverflow)?;1875        <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);18761877        if balance.value - value > 0 {1878            balance.value -= value;1879            <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), balance);1880        }1881        else {1882            <FungibleItemList<T>>::remove(collection_id, owner);1883        }18841885        Ok(())1886    }18871888    fn collection_exists(collection_id: CollectionId) -> DispatchResult {1889        ensure!(1890            <Collection<T>>::contains_key(collection_id),1891            Error::<T>::CollectionNotFound1892        );1893        Ok(())1894    }18951896    fn check_owner_permissions(collection_id: CollectionId, subject: T::AccountId) -> DispatchResult {1897        Self::collection_exists(collection_id)?;18981899        let target_collection = <Collection<T>>::get(collection_id);1900        ensure!(1901            subject == target_collection.owner,1902            Error::<T>::NoPermission1903        );19041905        Ok(())1906    }19071908    fn is_owner_or_admin_permissions(collection_id: CollectionId, subject: T::AccountId) -> bool {1909        let target_collection = <Collection<T>>::get(collection_id);1910        let mut result: bool = subject == target_collection.owner;1911        let exists = <AdminList<T>>::contains_key(collection_id);19121913        if !result & exists {1914            if <AdminList<T>>::get(collection_id).contains(&subject) {1915                result = true1916            }1917        }19181919        result1920    }19211922    fn check_owner_or_admin_permissions(1923        collection_id: CollectionId,1924        subject: T::AccountId,1925    ) -> DispatchResult {1926        Self::collection_exists(collection_id)?;1927        let result = Self::is_owner_or_admin_permissions(collection_id, subject.clone());19281929        ensure!(1930            result,1931            Error::<T>::NoPermission1932        );1933        Ok(())1934    }19351936    fn owned_amount(1937        subject: T::AccountId,1938        collection_id: CollectionId,1939        item_id: TokenId,1940    ) -> Option<u128> {1941        let target_collection = <Collection<T>>::get(collection_id);19421943        match target_collection.mode {1944            CollectionMode::NFT => {1945                if <NftItemList<T>>::get(collection_id, item_id).owner == subject {1946                    return Some(1)1947                }1948                None1949            },1950            CollectionMode::Fungible(_) => {1951                if <FungibleItemList<T>>::contains_key(collection_id, &subject) {1952                    return Some(<FungibleItemList<T>>::get(collection_id, &subject)1953                        .value);1954                }1955                None1956            },1957            CollectionMode::ReFungible => <ReFungibleItemList<T>>::get(collection_id, item_id)1958                .owner1959                .iter()1960                .find(|i| i.owner == subject)1961                .map(|i| i.fraction),1962            CollectionMode::Invalid => None,1963        }1964    }19651966    fn is_item_owner(subject: T::AccountId, collection_id: CollectionId, item_id: TokenId) -> bool {1967        let target_collection = <Collection<T>>::get(collection_id);19681969        match target_collection.mode {1970            CollectionMode::NFT => {1971                <NftItemList<T>>::get(collection_id, item_id).owner == subject1972            }1973            CollectionMode::Fungible(_) => {1974                <FungibleItemList<T>>::contains_key(collection_id, &subject)1975            }1976            CollectionMode::ReFungible => {1977                <ReFungibleItemList<T>>::get(collection_id, item_id)1978                    .owner1979                    .iter()1980                    .any(|i| i.owner == subject)1981            }1982            CollectionMode::Invalid => false,1983        }1984    }19851986    fn check_white_list(collection_id: CollectionId, address: &T::AccountId) -> DispatchResult {1987        let mes = Error::<T>::AddresNotInWhiteList;1988        ensure!(<WhiteList<T>>::contains_key(collection_id, address), mes);19891990        Ok(())1991    }19921993    /// Check if token exists. In case of Fungible, check if there is an entry for 1994    /// the owner in fungible balances double map1995    fn token_exists(1996        collection_id: CollectionId,1997        item_id: TokenId,1998        owner: &T::AccountId1999    ) -> DispatchResult {2000        let target_collection = <Collection<T>>::get(collection_id);2001        let exists = match target_collection.mode2002        {2003            CollectionMode::NFT => <NftItemList<T>>::contains_key(collection_id, item_id),2004            CollectionMode::Fungible(_)  => <FungibleItemList<T>>::contains_key(collection_id, owner),2005            CollectionMode::ReFungible  => <ReFungibleItemList<T>>::contains_key(collection_id, item_id),2006            _ => false2007        };20082009        ensure!(exists == true, Error::<T>::TokenNotFound);2010        Ok(())2011    }20122013    fn transfer_fungible(2014        collection_id: CollectionId,2015        value: u128,2016        owner: &T::AccountId,2017        recipient: &T::AccountId,2018    ) -> DispatchResult {2019        Self::token_exists(collection_id, 0, owner)?;20202021        let mut balance = <FungibleItemList<T>>::get(collection_id, owner);2022        ensure!(balance.value >= value, Error::<T>::TokenValueTooLow);20232024        // Send balance to recipient (updates balanceOf of recipient)2025        Self::add_fungible_item(collection_id, recipient, value)?;20262027        // update balanceOf of sender2028        <Balance<T>>::insert(collection_id, (*owner).clone(), balance.value - value);20292030        // Reduce or remove sender2031        if balance.value == value {2032            <FungibleItemList<T>>::remove(collection_id, owner);2033        }2034        else {2035            balance.value -= value;2036            <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), balance);2037        }20382039        Ok(())2040    }20412042    fn transfer_refungible(2043        collection_id: CollectionId,2044        item_id: TokenId,2045        value: u128,2046        owner: T::AccountId,2047        new_owner: T::AccountId,2048    ) -> DispatchResult {2049        Self::token_exists(collection_id, item_id, &owner)?;20502051        let full_item = <ReFungibleItemList<T>>::get(collection_id, item_id);2052        let item = full_item2053            .owner2054            .iter()2055            .filter(|i| i.owner == owner)2056            .next()2057            .ok_or(Error::<T>::NumOverflow)?;2058        let amount = item.fraction;20592060        ensure!(amount >= value, Error::<T>::TokenValueTooLow);20612062        // update balance2063        let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())2064            .checked_sub(value)2065            .ok_or(Error::<T>::NumOverflow)?;2066        <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);20672068        let balancenew_owner = <Balance<T>>::get(collection_id, new_owner.clone())2069            .checked_add(value)2070            .ok_or(Error::<T>::NumOverflow)?;2071        <Balance<T>>::insert(collection_id, new_owner.clone(), balancenew_owner);20722073        let old_owner = item.owner.clone();2074        let new_owner_has_account = full_item.owner.iter().any(|i| i.owner == new_owner);20752076        // transfer2077        if amount == value && !new_owner_has_account {2078            // change owner2079            // new owner do not have account2080            let mut new_full_item = full_item.clone();2081            new_full_item2082                .owner2083                .iter_mut()2084                .find(|i| i.owner == owner)2085                .unwrap()2086                .owner = new_owner.clone();2087            <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);20882089            // update index collection2090            Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;2091        } else {2092            let mut new_full_item = full_item.clone();2093            new_full_item2094                .owner2095                .iter_mut()2096                .find(|i| i.owner == owner)2097                .unwrap()2098                .fraction -= value;20992100            // separate amount2101            if new_owner_has_account {2102                // new owner has account2103                new_full_item2104                    .owner2105                    .iter_mut()2106                    .find(|i| i.owner == new_owner)2107                    .unwrap()2108                    .fraction += value;2109            } else {2110                // new owner do not have account2111                new_full_item.owner.push(Ownership {2112                    owner: new_owner.clone(),2113                    fraction: value,2114                });2115                Self::add_token_index(collection_id, item_id, &new_owner)?;2116            }21172118            <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);2119        }21202121        Ok(())2122    }21232124    fn transfer_nft(2125        collection_id: CollectionId,2126        item_id: TokenId,2127        sender: T::AccountId,2128        new_owner: T::AccountId,2129    ) -> DispatchResult {2130        Self::token_exists(collection_id, item_id, &sender)?;21312132        let mut item = <NftItemList<T>>::get(collection_id, item_id);21332134        ensure!(2135            sender == item.owner,2136            Error::<T>::MustBeTokenOwner2137        );21382139        // update balance2140        let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())2141            .checked_sub(1)2142            .ok_or(Error::<T>::NumOverflow)?;2143        <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);21442145        let balancenew_owner = <Balance<T>>::get(collection_id, new_owner.clone())2146            .checked_add(1)2147            .ok_or(Error::<T>::NumOverflow)?;2148        <Balance<T>>::insert(collection_id, new_owner.clone(), balancenew_owner);21492150        // change owner2151        let old_owner = item.owner.clone();2152        item.owner = new_owner.clone();2153        <NftItemList<T>>::insert(collection_id, item_id, item);21542155        // update index collection2156        Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;21572158        Ok(())2159    }2160    2161    fn set_re_fungible_variable_data(2162        collection_id: CollectionId,2163        item_id: TokenId,2164        data: Vec<u8>2165    ) -> DispatchResult {2166        let mut item = <ReFungibleItemList<T>>::get(collection_id, item_id);21672168        item.variable_data = data;21692170        <ReFungibleItemList<T>>::insert(collection_id, item_id, item);21712172        Ok(())2173    }21742175    fn set_nft_variable_data(2176        collection_id: CollectionId,2177        item_id: TokenId,2178        data: Vec<u8>2179    ) -> DispatchResult {2180        let mut item = <NftItemList<T>>::get(collection_id, item_id);2181        2182        item.variable_data = data;21832184        <NftItemList<T>>::insert(collection_id, item_id, item);2185        2186        Ok(())2187    }21882189    fn init_collection(item: &CollectionType<T::AccountId>) {2190        // check params2191        assert!(2192            item.decimal_points <= MAX_DECIMAL_POINTS,2193            "decimal_points parameter must be lower than MAX_DECIMAL_POINTS"2194        );2195        assert!(2196            item.name.len() <= 64,2197            "Collection name can not be longer than 63 char"2198        );2199        assert!(2200            item.name.len() <= 256,2201            "Collection description can not be longer than 255 char"2202        );2203        assert!(2204            item.token_prefix.len() <= 16,2205            "Token prefix can not be longer than 15 char"2206        );22072208        // Generate next collection ID2209        let next_id = CreatedCollectionCount::get()2210            .checked_add(1)2211            .unwrap();22122213        CreatedCollectionCount::put(next_id);2214    }22152216    fn init_nft_token(collection_id: CollectionId, item: &NftItemType<T::AccountId>) {2217        let current_index = <ItemListIndex>::get(collection_id)2218            .checked_add(1)2219            .unwrap();22202221        let item_owner = item.owner.clone();2222        Self::add_token_index(collection_id, current_index, &item.owner).unwrap();22232224        <ItemListIndex>::insert(collection_id, current_index);22252226        // Update balance2227        let new_balance = <Balance<T>>::get(collection_id, &item_owner)2228            .checked_add(1)2229            .unwrap();2230        <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);2231    }22322233    fn init_fungible_token(collection_id: CollectionId, owner: &T::AccountId, item: &FungibleItemType) {2234        let current_index = <ItemListIndex>::get(collection_id)2235            .checked_add(1)2236            .unwrap();22372238        Self::add_token_index(collection_id, current_index, owner).unwrap();22392240        <ItemListIndex>::insert(collection_id, current_index);22412242        // Update balance2243        let new_balance = <Balance<T>>::get(collection_id, owner)2244            .checked_add(item.value)2245            .unwrap();2246        <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);2247    }22482249    fn init_refungible_token(collection_id: CollectionId, item: &ReFungibleItemType<T::AccountId>) {2250        let current_index = <ItemListIndex>::get(collection_id)2251            .checked_add(1)2252            .unwrap();22532254        let value = item.owner.first().unwrap().fraction;2255        let owner = item.owner.first().unwrap().owner.clone();22562257        Self::add_token_index(collection_id, current_index, &owner).unwrap();22582259        <ItemListIndex>::insert(collection_id, current_index);22602261        // Update balance2262        let new_balance = <Balance<T>>::get(collection_id, &owner)2263            .checked_add(value)2264            .unwrap();2265        <Balance<T>>::insert(collection_id, owner.clone(), new_balance);2266    }22672268    fn add_token_index(collection_id: CollectionId, item_index: TokenId, owner: &T::AccountId) -> DispatchResult {22692270        // add to account limit2271        if <AccountItemCount<T>>::contains_key(owner) {22722273            // bound Owned tokens by a single address2274            let count = <AccountItemCount<T>>::get(owner);2275            ensure!(count < ChainLimit::get().account_token_ownership_limit, Error::<T>::AddressOwnershipLimitExceeded);22762277            <AccountItemCount<T>>::insert(owner.clone(), count2278                .checked_add(1)2279                .ok_or(Error::<T>::NumOverflow)?);2280        }2281        else {2282            <AccountItemCount<T>>::insert(owner.clone(), 1);2283        }22842285        let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner);2286        if list_exists {2287            let mut list = <AddressTokens<T>>::get(collection_id, owner);2288            let item_contains = list.contains(&item_index.clone());22892290            if !item_contains {2291                list.push(item_index.clone());2292            }22932294            <AddressTokens<T>>::insert(collection_id, owner.clone(), list);2295        } else {2296            let mut itm = Vec::new();2297            itm.push(item_index.clone());2298            <AddressTokens<T>>::insert(collection_id, owner.clone(), itm);2299        }23002301        Ok(())2302    }23032304    fn remove_token_index(2305        collection_id: CollectionId,2306        item_index: TokenId,2307        owner: &T::AccountId,2308    ) -> DispatchResult {23092310        // update counter2311        <AccountItemCount<T>>::insert(owner.clone(), 2312            <AccountItemCount<T>>::get(owner)2313            .checked_sub(1)2314            .ok_or(Error::<T>::NumOverflow)?);231523162317        let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner);2318        if list_exists {2319            let mut list = <AddressTokens<T>>::get(collection_id, owner);2320            let item_contains = list.contains(&item_index.clone());23212322            if item_contains {2323                list.retain(|&item| item != item_index);2324                <AddressTokens<T>>::insert(collection_id, owner.clone(), list);2325            }2326        }23272328        Ok(())2329    }23302331    fn move_token_index(2332        collection_id: CollectionId,2333        item_index: TokenId,2334        old_owner: &T::AccountId,2335        new_owner: &T::AccountId,2336    ) -> DispatchResult {2337        Self::remove_token_index(collection_id, item_index, old_owner)?;2338        Self::add_token_index(collection_id, item_index, new_owner)?;23392340        Ok(())2341    }2342    2343    fn ensure_contract_owned(account: T::AccountId, contract: &T::AccountId) -> DispatchResult {2344        if <ContractOwner<T>>::contains_key(contract.clone()) {2345            let owner = <ContractOwner<T>>::get(contract);2346            ensure!(account == owner, Error::<T>::NoPermission);2347        } else {2348            fail!(Error::<T>::NoPermission);2349        }23502351        Ok(())2352    }2353}23542355////////////////////////////////////////////////////////////////////////////////////////////////////2356// Economic models2357// #region23582359/// Fee multiplier.2360pub type Multiplier = FixedU128;23612362type BalanceOf<T> = <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::Balance;23632364/// Require the transactor pay for themselves and maybe include a tip to gain additional priority2365/// in the queue.2366#[derive(Encode, Decode, Clone, Eq, PartialEq)]2367pub struct ChargeTransactionPayment<T: Config>(#[codec(compact)] BalanceOf<T>);23682369impl<T: Config + Send + Sync> sp_std::fmt::Debug 2370    for ChargeTransactionPayment<T>2371{2372	#[cfg(feature = "std")]2373	fn fmt(&self, f: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {2374		write!(f, "ChargeTransactionPayment<{:?}>", self.0)2375	}2376	#[cfg(not(feature = "std"))]2377	fn fmt(&self, _: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {2378		Ok(())2379	}2380}23812382impl<T: Config> ChargeTransactionPayment<T>2383where2384    T::Call: Dispatchable<Info=DispatchInfo, PostInfo=PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,2385    BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,2386    T::AccountId: AsRef<[u8]>,2387    T::AccountId: UncheckedFrom<T::Hash>,2388{2389    fn traditional_fee(2390        len: usize,2391        info: &DispatchInfoOf<T::Call>,2392        tip: BalanceOf<T>,2393    ) -> BalanceOf<T>2394    where2395        T::Call: Dispatchable<Info = DispatchInfo>,2396    {2397        <pallet_transaction_payment::Module<T>>::compute_fee(len as u32, info, tip)2398    }23992400	fn get_priority(len: usize, info: &DispatchInfoOf<T::Call>, final_fee: BalanceOf<T>) -> TransactionPriority {2401        let weight_saturation = T::BlockWeights::get().max_block / info.weight.max(1);2402        let max_block_length = *T::BlockLength::get().max.get(DispatchClass::Normal);2403        let len_saturation = max_block_length as u64 / (len as u64).max(1);2404        let coefficient: BalanceOf<T> = weight_saturation2405            .min(len_saturation)2406            .saturated_into::<BalanceOf<T>>();2407        final_fee2408            .saturating_mul(coefficient)2409            .saturated_into::<TransactionPriority>()2410    }24112412    fn withdraw_fee(2413        &self,2414        who: &T::AccountId,2415        call: &T::Call,2416        info: &DispatchInfoOf<T::Call>,2417        len: usize,2418	) -> Result<2419		(2420			BalanceOf<T>,2421			<<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::LiquidityInfo,2422		),2423		TransactionValidityError,2424	> {2425        let tip = self.0;24262427        // Set fee based on call type. Creating collection costs 1 Unique.2428        // All other transactions have traditional fees so far2429        // let fee = match call.is_sub_type() {2430        //     Some(Call::create_collection(..)) => <BalanceOf<T>>::from(1_000_000_000),2431        //     _ => Self::traditional_fee(len, info, tip), // Flat fee model, use only for testing purposes2432        //                                                 // _ => <BalanceOf<T>>::from(100)2433        // };2434        let fee = Self::traditional_fee(len, info, tip);24352436        // Only mess with balances if fee is not zero.2437        if fee.is_zero() {2438            return <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::withdraw_fee(who, call, info, fee, tip)2439			.map(|i| (fee, i));2440        }24412442        // Determine who is paying transaction fee based on ecnomic model2443        // Parse call to extract collection ID and access collection sponsor2444        let mut sponsor: T::AccountId = match IsSubType::<Call<T>>::is_sub_type(call) {2445            Some(Call::create_item(collection_id, _owner, _properties)) => {24462447                // sponsor timeout2448                let block_number = <system::Module<T>>::block_number() as T::BlockNumber;24492450                let limit = <Collection<T>>::get(collection_id).limits.sponsor_transfer_timeout;2451                let mut sponsored = true;2452                if <CreateItemBasket<T>>::contains_key((collection_id, &who)) {2453                    let last_tx_block = <CreateItemBasket<T>>::get((collection_id, &who));2454                    let limit_time = last_tx_block + limit.into();2455                    if block_number <= limit_time {2456                        sponsored = false;2457                    }2458                }2459                if sponsored {2460                    <CreateItemBasket<T>>::insert((collection_id, who.clone()), block_number);2461                }24622463                // check free create limit2464                if (<Collection<T>>::get(collection_id).limits.sponsored_data_size >= (_properties.len() as u32)) &&2465                   (<Collection<T>>::get(collection_id).sponsor_confirmed) &&2466                   (sponsored)2467                {2468                    <Collection<T>>::get(collection_id).sponsor2469                } else {2470                    T::AccountId::default()2471                }2472            }2473            Some(Call::transfer(_new_owner, collection_id, item_id, _value)) => {2474                2475                let mut sponsor_transfer = false;2476                if <Collection<T>>::get(collection_id).sponsor_confirmed {24772478                    let collection_limits = <Collection<T>>::get(collection_id).limits;2479                    let collection_mode = <Collection<T>>::get(collection_id).mode;2480    2481                    // sponsor timeout2482                    let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2483                    sponsor_transfer = match collection_mode {2484                        CollectionMode::NFT => {2485    2486                            // get correct limit2487                            let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2488                                collection_limits.sponsor_transfer_timeout2489                            } else {2490                                ChainLimit::get().nft_sponsor_transfer_timeout2491                            };2492    2493                            let mut sponsored = true;2494                            if <NftTransferBasket<T>>::contains_key(collection_id, item_id) {2495                                let last_tx_block = <NftTransferBasket<T>>::get(collection_id, item_id);2496                                let limit_time = last_tx_block + limit.into();2497                                if block_number <= limit_time {2498                                    sponsored = false;2499                                }2500                            }2501                            if sponsored {2502                                <NftTransferBasket<T>>::insert(collection_id, item_id, block_number);2503                            }25042505                            sponsored2506                        }2507                        CollectionMode::Fungible(_) => {2508    2509                            // get correct limit2510                            let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2511                                collection_limits.sponsor_transfer_timeout2512                            } else {2513                                ChainLimit::get().fungible_sponsor_transfer_timeout2514                            };2515    2516                            let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2517                            let mut sponsored = true;2518                            if <FungibleTransferBasket<T>>::contains_key(collection_id, who) {2519                                let last_tx_block = <FungibleTransferBasket<T>>::get(collection_id, who);2520                                let limit_time = last_tx_block + limit.into();2521                                if block_number <= limit_time {2522                                    sponsored = false;2523                                }2524                            }2525                            if sponsored {2526                                <FungibleTransferBasket<T>>::insert(collection_id, who, block_number);2527                            }25282529                            sponsored2530                        }2531                        CollectionMode::ReFungible => {2532    2533                            // get correct limit2534                            let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2535                                collection_limits.sponsor_transfer_timeout2536                            } else {2537                                ChainLimit::get().refungible_sponsor_transfer_timeout2538                            };2539    2540                            let mut sponsored = true;2541                            if <ReFungibleTransferBasket<T>>::contains_key(collection_id, item_id) {2542                                let last_tx_block = <ReFungibleTransferBasket<T>>::get(collection_id, item_id);2543                                let limit_time = last_tx_block + limit.into();2544                                if block_number <= limit_time {2545                                    sponsored = false;2546                                }2547                            }2548                            if sponsored {2549                                <ReFungibleTransferBasket<T>>::insert(collection_id, item_id, block_number);2550                            }25512552                            sponsored2553                        }2554                        _ => {2555                            false2556                        },2557                    };2558                }25592560                if !sponsor_transfer {2561                    T::AccountId::default()2562                } else {2563                    <Collection<T>>::get(collection_id).sponsor2564                }2565            }25662567            _ => T::AccountId::default(),2568        };25692570        // Sponsor smart contracts2571        sponsor = match IsSubType::<pallet_contracts::Call<T>>::is_sub_type(call) {25722573            // On instantiation: set the contract owner2574            Some(pallet_contracts::Call::instantiate(_endowment, _gas_limit, code_hash, _data, salt)) => {25752576                let new_contract_address = <pallet_contracts::Module<T>>::contract_address(2577                    &who,2578                    code_hash,2579                    salt,2580                );2581                <ContractOwner<T>>::insert(new_contract_address.clone(), who.clone());25822583                T::AccountId::default()2584            },25852586            // On instantiation with code: set the contract owner2587            Some(pallet_contracts::Call::instantiate_with_code(_endowment, _gas_limit, _code, _data, _salt))  => {25882589                let new_contract_address = <pallet_contracts::Module<T>>::contract_address(2590                    &who,2591                    &T::Hashing::hash(&_code),2592                    _salt,2593                );25942595                <ContractOwner<T>>::insert(new_contract_address.clone(), who.clone());25962597                T::AccountId::default()2598            }25992600            // When the contract is called, check if the sponsoring is enabled and pay fees from contract endowment if it is2601            Some(pallet_contracts::Call::call(dest, _value, _gas_limit, _data)) => {26022603                let called_contract: T::AccountId = T::Lookup::lookup((*dest).clone()).unwrap_or(T::AccountId::default());26042605                let owned_contract = <ContractOwner<T>>::contains_key(called_contract.clone())2606                  && <ContractOwner<T>>::get(called_contract.clone()) == *who;2607                let white_list_enabled = <ContractWhiteListEnabled<T>>::contains_key(called_contract.clone()) && <ContractWhiteListEnabled<T>>::get(called_contract.clone());2608                  2609                if !owned_contract && white_list_enabled {2610                    if !<ContractWhiteList<T>>::contains_key(called_contract.clone(), who) {2611                        return Err(InvalidTransaction::Call.into());2612                    }2613                }26142615                let mut sponsor_transfer = false;2616                if <ContractSponsoringRateLimit<T>>::contains_key(called_contract.clone()) {2617                    let last_tx_block = <ContractSponsorBasket<T>>::get((&called_contract, &who));2618                    let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2619                    let rate_limit = <ContractSponsoringRateLimit<T>>::get(&called_contract);2620                    let limit_time = last_tx_block + rate_limit;26212622                    if block_number >= limit_time {2623                        <ContractSponsorBasket<T>>::insert((called_contract.clone(), who.clone()), block_number);2624                        sponsor_transfer = true;2625                    }2626                } else {2627                    sponsor_transfer = false;2628                }2629               2630                2631                let mut sp = T::AccountId::default();2632                if sponsor_transfer {2633                    if <ContractSelfSponsoring<T>>::contains_key(called_contract.clone()) {2634                        if <ContractSelfSponsoring<T>>::get(called_contract.clone()) {2635                            sp = called_contract;2636                        }2637                    }2638                }26392640                sp2641            },26422643            _ => sponsor,2644        };26452646        let mut who_pays_fee: T::AccountId = sponsor.clone();2647        if sponsor == T::AccountId::default() {2648            who_pays_fee = who.clone();2649        }26502651		<<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::withdraw_fee(&who_pays_fee, call, info, fee, tip)2652			.map(|i| (fee, i))2653    }2654}265526562657impl<T: Config + Send + Sync> SignedExtension2658    for ChargeTransactionPayment<T>2659where2660    BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,2661    T::Call: Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,2662    T::AccountId: AsRef<[u8]>,2663    T::AccountId: UncheckedFrom<T::Hash>,2664{2665    const IDENTIFIER: &'static str = "ChargeTransactionPayment";2666    type AccountId = T::AccountId;2667    type Call = T::Call;2668    type AdditionalSigned = ();2669    type Pre = (2670        // tip2671        BalanceOf<T>,2672        // who pays fee2673        Self::AccountId,2674		// imbalance resulting from withdrawing the fee2675		<<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::LiquidityInfo,2676    );2677    fn additional_signed(&self) -> sp_std::result::Result<(), TransactionValidityError> {2678        Ok(())2679    }26802681    fn validate(2682        &self,2683        who: &Self::AccountId,2684        call: &Self::Call,2685        info: &DispatchInfoOf<Self::Call>,2686        len: usize,2687    ) -> TransactionValidity {2688		let (fee, _) = self.withdraw_fee(who, call, info, len)?;2689		Ok(ValidTransaction {2690			priority: Self::get_priority(len, info, fee),2691			..Default::default()2692		})2693    }26942695    fn pre_dispatch(2696        self,2697        who: &Self::AccountId,2698        call: &Self::Call,2699        info: &DispatchInfoOf<Self::Call>,2700        len: usize,2701    ) -> Result<Self::Pre, TransactionValidityError> {2702        let (_fee, imbalance) = self.withdraw_fee(who, call, info, len)?;2703        Ok((self.0, who.clone(), imbalance))2704    }27052706    fn post_dispatch(2707        pre: Self::Pre,2708        info: &DispatchInfoOf<Self::Call>,2709        post_info: &PostDispatchInfoOf<Self::Call>,2710        len: usize,2711        _result: &DispatchResult,2712    ) -> Result<(), TransactionValidityError> {2713		let (tip, who, imbalance) = pre;2714		let actual_fee = pallet_transaction_payment::Module::<T>::compute_actual_fee(2715			len as u32,2716			info,2717			post_info,2718			tip,2719		);2720		<T as pallet_transaction_payment::Config>::OnChargeTransaction::correct_and_deposit_fee(&who, info, post_info, actual_fee, tip, imbalance)?;2721		Ok(())2722    }2723}27242725// #endregion