git.delta.rocks / unique-network / refs/commits / bc41c8bcd94a

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);11201121            let bypasses_limits = target_collection.limits.owner_can_transfer &&1122                Self::is_owner_or_admin_permissions(1123                    collection_id,1124                    sender.clone(),1125                );11261127            let allowance_limit = if bypasses_limits {1128                None1129            } else if let Some(amount) = Self::owned_amount(1130                sender.clone(),1131                collection_id,1132                item_id,1133            ) {1134                Some(amount)1135            } else {1136                fail!(Error::<T>::NoPermission);1137            };11381139            if target_collection.access == AccessMode::WhiteList {1140                Self::check_white_list(collection_id, &sender)?;1141                Self::check_white_list(collection_id, &spender)?;1142            }11431144            let allowance_exists = <Allowances<T>>::contains_key(collection_id, (item_id, &sender, &spender));1145            let mut allowance: u128 = amount;1146            if allowance_exists {1147                allowance += <Allowances<T>>::get(collection_id, (item_id, &sender, &spender));1148            }1149            if let Some(limit) = allowance_limit {1150                ensure!(limit >= allowance, Error::<T>::TokenValueTooLow);1151            }1152            <Allowances<T>>::insert(collection_id, (item_id, sender.clone(), spender.clone()), allowance);11531154            Ok(())1155        }1156        1157        /// 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.1158        /// 1159        /// # Permissions1160        /// * Collection Owner1161        /// * Collection Admin1162        /// * Current NFT owner1163        /// * Address approved by current NFT owner1164        /// 1165        /// # Arguments1166        /// 1167        /// * from: Address that owns token.1168        /// 1169        /// * recipient: Address of token recipient.1170        /// 1171        /// * collection_id.1172        /// 1173        /// * item_id: ID of the item.1174        /// 1175        /// * value: Amount to transfer.1176        #[weight = <T as Config>::WeightInfo::transfer_from()]1177        pub fn transfer_from(origin, from: T::AccountId, recipient: T::AccountId, collection_id: CollectionId, item_id: TokenId, value: u128 ) -> DispatchResult {11781179            let sender = ensure_signed(origin)?;1180            let mut appoved_transfer = false;11811182            // Check approval1183            let mut approval: u128 = 0;1184            if <Allowances<T>>::contains_key(collection_id, (item_id, &from, &sender)) {1185                approval = <Allowances<T>>::get(collection_id, (item_id, &from, &sender));1186                ensure!(approval >= value, Error::<T>::TokenValueNotEnough);1187                appoved_transfer = true;1188            }11891190            let target_collection = <Collection<T>>::get(collection_id);11911192            // Limits check1193            Self::is_correct_transfer(collection_id, &target_collection, &recipient)?;11941195            // Transfer permissions check         1196            ensure!(1197                appoved_transfer || 1198                (1199                    target_collection.limits.owner_can_transfer &&1200                    Self::is_owner_or_admin_permissions(collection_id, sender.clone())1201                ),1202                Error::<T>::NoPermission1203            );12041205            if target_collection.access == AccessMode::WhiteList {1206                Self::check_white_list(collection_id, &sender)?;1207                Self::check_white_list(collection_id, &recipient)?;1208            }12091210            // Reduce approval by transferred amount or remove if remaining approval drops to 01211            if approval.checked_sub(value).unwrap_or(0) > 0 {1212                <Allowances<T>>::insert(collection_id, (item_id, &from, &sender), approval - value);1213            }1214            else {1215                <Allowances<T>>::remove(collection_id, (item_id, &from, &sender));1216            }12171218            match target_collection.mode1219            {1220                CollectionMode::NFT => Self::transfer_nft(collection_id, item_id, from, recipient)?,1221                CollectionMode::Fungible(_)  => Self::transfer_fungible(collection_id, value, &from, &recipient)?,1222                CollectionMode::ReFungible  => Self::transfer_refungible(collection_id, item_id, value, from.clone(), recipient)?,1223                _ => ()1224            };12251226            Ok(())1227        }12281229        // #[weight = 0]1230        // pub fn safe_transfer_from(origin, collection_id: CollectionId, item_id: TokenId, new_owner: T::AccountId) -> DispatchResult {12311232        //     // let no_perm_mes = "You do not have permissions to modify this collection";1233        //     // ensure!(<ApprovedList<T>>::contains_key((collection_id, item_id)), no_perm_mes);1234        //     // let list_itm = <ApprovedList<T>>::get((collection_id, item_id));1235        //     // ensure!(list_itm.contains(&new_owner.clone()), no_perm_mes);12361237        //     // // on_nft_received  call12381239        //     // Self::transfer(origin, collection_id, item_id, new_owner)?;12401241        //     Ok(())1242        // }12431244        /// Set off-chain data schema.1245        /// 1246        /// # Permissions1247        /// 1248        /// * Collection Owner1249        /// * Collection Admin1250        /// 1251        /// # Arguments1252        /// 1253        /// * collection_id.1254        /// 1255        /// * schema: String representing the offchain data schema.1256        #[weight = <T as Config>::WeightInfo::set_variable_meta_data()]1257        pub fn set_variable_meta_data (1258            origin,1259            collection_id: CollectionId,1260            item_id: TokenId,1261            data: Vec<u8>1262        ) -> DispatchResult {1263            let sender = ensure_signed(origin)?;1264            1265            Self::collection_exists(collection_id)?;1266            Self::token_exists(collection_id, item_id, &sender)?;12671268            ensure!(ChainLimit::get().custom_data_limit >= data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);12691270            // Modify permissions check1271            let target_collection = <Collection<T>>::get(collection_id);1272            ensure!(Self::is_item_owner(sender.clone(), collection_id, item_id) ||1273                Self::is_owner_or_admin_permissions(collection_id, sender.clone()),1274                Error::<T>::NoPermission);12751276            match target_collection.mode1277            {1278                CollectionMode::NFT => Self::set_nft_variable_data(collection_id, item_id, data)?,1279                CollectionMode::ReFungible  => Self::set_re_fungible_variable_data(collection_id, item_id, data)?,1280                CollectionMode::Fungible(_) => fail!(Error::<T>::CantStoreMetadataInFungibleTokens),1281                _ => fail!(Error::<T>::UnexpectedCollectionType)1282            };12831284            Ok(())1285        }1286 1287        /// Set schema standard1288        /// ImageURL1289        /// Unique1290        /// 1291        /// # Permissions1292        /// 1293        /// * Collection Owner1294        /// * Collection Admin1295        /// 1296        /// # Arguments1297        /// 1298        /// * collection_id.1299        /// 1300        /// * schema: SchemaVersion: enum1301        #[weight = <T as Config>::WeightInfo::set_schema_version()]1302        pub fn set_schema_version(1303            origin,1304            collection_id: CollectionId,1305            version: SchemaVersion1306        ) -> DispatchResult {1307            let sender = ensure_signed(origin)?;1308            Self::check_owner_or_admin_permissions(collection_id, sender.clone())?;1309            let mut target_collection = <Collection<T>>::get(collection_id);1310            target_collection.schema_version = version;1311            <Collection<T>>::insert(collection_id, target_collection);13121313            Ok(())1314        }13151316        /// Set off-chain data schema.1317        /// 1318        /// # Permissions1319        /// 1320        /// * Collection Owner1321        /// * Collection Admin1322        /// 1323        /// # Arguments1324        /// 1325        /// * collection_id.1326        /// 1327        /// * schema: String representing the offchain data schema.1328        #[weight = <T as Config>::WeightInfo::set_offchain_schema()]1329        pub fn set_offchain_schema(1330            origin,1331            collection_id: CollectionId,1332            schema: Vec<u8>1333        ) -> DispatchResult {1334            let sender = ensure_signed(origin)?;1335            Self::check_owner_or_admin_permissions(collection_id, sender.clone())?;13361337            // check schema limit1338            ensure!(schema.len() as u32 <= ChainLimit::get().offchain_schema_limit, "");13391340            let mut target_collection = <Collection<T>>::get(collection_id);1341            target_collection.offchain_schema = schema;1342            <Collection<T>>::insert(collection_id, target_collection);13431344            Ok(())1345        }13461347        /// Set const on-chain data schema.1348        /// 1349        /// # Permissions1350        /// 1351        /// * Collection Owner1352        /// * Collection Admin1353        /// 1354        /// # Arguments1355        /// 1356        /// * collection_id.1357        /// 1358        /// * schema: String representing the const on-chain data schema.1359        #[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1360        pub fn set_const_on_chain_schema (1361            origin,1362            collection_id: CollectionId,1363            schema: Vec<u8>1364        ) -> DispatchResult {1365            let sender = ensure_signed(origin)?;1366            Self::check_owner_or_admin_permissions(collection_id, sender.clone())?;13671368            // check schema limit1369            ensure!(schema.len() as u32 <= ChainLimit::get().const_on_chain_schema_limit, "");13701371            let mut target_collection = <Collection<T>>::get(collection_id);1372            target_collection.const_on_chain_schema = schema;1373            <Collection<T>>::insert(collection_id, target_collection);13741375            Ok(())1376        }13771378        /// Set variable on-chain data schema.1379        /// 1380        /// # Permissions1381        /// 1382        /// * Collection Owner1383        /// * Collection Admin1384        /// 1385        /// # Arguments1386        /// 1387        /// * collection_id.1388        /// 1389        /// * schema: String representing the variable on-chain data schema.1390        #[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1391        pub fn set_variable_on_chain_schema (1392            origin,1393            collection_id: CollectionId,1394            schema: Vec<u8>1395        ) -> DispatchResult {1396            let sender = ensure_signed(origin)?;1397            Self::check_owner_or_admin_permissions(collection_id, sender.clone())?;13981399            // check schema limit1400            ensure!(schema.len() as u32 <= ChainLimit::get().variable_on_chain_schema_limit, "");14011402            let mut target_collection = <Collection<T>>::get(collection_id);1403            target_collection.variable_on_chain_schema = schema;1404            <Collection<T>>::insert(collection_id, target_collection);14051406            Ok(())1407        }14081409        // Sudo permissions function1410        #[weight = <T as Config>::WeightInfo::set_chain_limits()]1411        pub fn set_chain_limits(1412            origin,1413            limits: ChainLimits1414        ) -> DispatchResult {14151416            #[cfg(not(feature = "runtime-benchmarks"))]1417            ensure_root(origin)?;14181419            <ChainLimit>::put(limits);1420            Ok(())1421        }14221423        /// Enable smart contract self-sponsoring.1424        /// 1425        /// # Permissions1426        /// 1427        /// * Contract Owner1428        /// 1429        /// # Arguments1430        /// 1431        /// * contract address1432        /// * enable flag1433        /// 1434        #[weight = <T as Config>::WeightInfo::enable_contract_sponsoring()]1435        pub fn enable_contract_sponsoring(1436            origin,1437            contract_address: T::AccountId,1438            enable: bool1439        ) -> DispatchResult {14401441            let sender = ensure_signed(origin)?;14421443            #[cfg(feature = "runtime-benchmarks")]1444            <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());14451446            Self::ensure_contract_owned(sender, &contract_address)?;14471448            <ContractSelfSponsoring<T>>::insert(contract_address, enable);1449            Ok(())1450        }14511452        /// Set the rate limit for contract sponsoring to specified number of blocks.1453        /// 1454        /// If not set (has the default value of 0 blocks), the sponsoring will be disabled. 1455        /// If set to the number B (for blocks), the transactions will be sponsored with a rate 1456        /// limit of B, i.e. fees for every transaction sent to this smart contract will be paid 1457        /// from contract endowment if there are at least B blocks between such transactions. 1458        /// Nonetheless, if transactions are sent more frequently, the fees are paid by the sender.1459        /// 1460        /// # Permissions1461        /// 1462        /// * Contract Owner1463        /// 1464        /// # Arguments1465        /// 1466        /// -`contract_address`: Address of the contract to sponsor1467        /// -`rate_limit`: Number of blocks to wait until the next sponsored transaction is allowed1468        /// 1469        #[weight = <T as Config>::WeightInfo::set_contract_sponsoring_rate_limit()]1470        pub fn set_contract_sponsoring_rate_limit(1471            origin,1472            contract_address: T::AccountId,1473            rate_limit: T::BlockNumber1474        ) -> DispatchResult {1475            let sender = ensure_signed(origin)?;14761477            #[cfg(feature = "runtime-benchmarks")]1478            <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());14791480            Self::ensure_contract_owned(sender, &contract_address)?;1481            <ContractSponsoringRateLimit<T>>::insert(contract_address, rate_limit);1482            Ok(())1483        }14841485        /// Enable the white list for a contract. Only addresses added to the white list with addToContractWhiteList will be able to call this smart contract.1486        /// 1487        /// # Permissions1488        /// 1489        /// * Address that deployed smart contract.1490        /// 1491        /// # Arguments1492        /// 1493        /// -`contract_address`: Address of the contract.1494        /// 1495        /// - `enable`: .  1496        #[weight = <T as Config>::WeightInfo::toggle_contract_white_list()]1497        pub fn toggle_contract_white_list(1498            origin,1499            contract_address: T::AccountId,1500            enable: bool1501        ) -> DispatchResult {1502            let sender = ensure_signed(origin)?;15031504            #[cfg(feature = "runtime-benchmarks")]1505            <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());15061507            Self::ensure_contract_owned(sender, &contract_address)?;1508            <ContractWhiteListEnabled<T>>::insert(contract_address, enable);1509            Ok(())1510        }1511        1512        /// Add an address to smart contract white list.1513        /// 1514        /// # Permissions1515        /// 1516        /// * Address that deployed smart contract.1517        /// 1518        /// # Arguments1519        /// 1520        /// -`contract_address`: Address of the contract.1521        ///1522        /// -`account_address`: Address to add.1523        #[weight = <T as Config>::WeightInfo::add_to_contract_white_list()]1524        pub fn add_to_contract_white_list(1525            origin,1526            contract_address: T::AccountId,1527            account_address: T::AccountId1528        ) -> DispatchResult {1529            let sender = ensure_signed(origin)?;15301531            #[cfg(feature = "runtime-benchmarks")]1532            <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());1533            1534            Self::ensure_contract_owned(sender, &contract_address)?;      1535            <ContractWhiteList<T>>::insert(contract_address, account_address, true);1536            Ok(())1537        }15381539        /// Remove an address from smart contract white list.1540        /// 1541        /// # Permissions1542        /// 1543        /// * Address that deployed smart contract.1544        /// 1545        /// # Arguments1546        /// 1547        /// -`contract_address`: Address of the contract.1548        ///1549        /// -`account_address`: Address to remove.1550        #[weight = <T as Config>::WeightInfo::remove_from_contract_white_list()]1551        pub fn remove_from_contract_white_list(1552            origin,1553            contract_address: T::AccountId,1554            account_address: T::AccountId1555        ) -> DispatchResult {1556            let sender = ensure_signed(origin)?;15571558            #[cfg(feature = "runtime-benchmarks")]1559            <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());15601561            Self::ensure_contract_owned(sender, &contract_address)?;1562            <ContractWhiteList<T>>::remove(contract_address, account_address);1563            Ok(())1564        }15651566        #[weight = <T as Config>::WeightInfo::set_collection_limits()]1567        pub fn set_collection_limits(1568            origin,1569            collection_id: u32,1570            new_limits: CollectionLimits,1571        ) -> DispatchResult {1572            let sender = ensure_signed(origin)?;1573            Self::check_owner_permissions(collection_id, sender.clone())?;1574            let mut target_collection = <Collection<T>>::get(collection_id);1575            let old_limits = target_collection.limits;1576            let chain_limits = ChainLimit::get();15771578            // collection bounds1579            ensure!(new_limits.sponsor_transfer_timeout <= MAX_SPONSOR_TIMEOUT &&1580                new_limits.account_token_ownership_limit <= MAX_TOKEN_OWNERSHIP && 1581                new_limits.sponsored_data_size <= chain_limits.custom_data_limit,1582                Error::<T>::CollectionLimitBoundsExceeded);15831584            // token_limit   check  prev1585            ensure!(old_limits.token_limit >= new_limits.token_limit, Error::<T>::CollectionTokenLimitExceeded);1586            ensure!(new_limits.token_limit > 0, Error::<T>::CollectionTokenLimitExceeded);15871588            ensure!(1589                (old_limits.owner_can_transfer || !new_limits.owner_can_transfer) &&1590                (old_limits.owner_can_destroy || !new_limits.owner_can_destroy),1591                Error::<T>::OwnerPermissionsCantBeReverted,1592            );15931594            target_collection.limits = new_limits;1595            <Collection<T>>::insert(collection_id, target_collection);15961597            Ok(())1598        } 1599    }1600}16011602impl<T: Config> Module<T> {16031604    pub fn transfer_internal(sender: T::AccountId, recipient: T::AccountId, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {16051606        let target_collection = <Collection<T>>::get(collection_id);16071608        // Limits check1609        Self::is_correct_transfer(collection_id, &target_collection, &recipient)?;16101611        // Transfer permissions check1612        ensure!(Self::is_item_owner(sender.clone(), collection_id, item_id) ||1613            Self::is_owner_or_admin_permissions(collection_id, sender.clone()),1614            Error::<T>::NoPermission);16151616        if target_collection.access == AccessMode::WhiteList {1617            Self::check_white_list(collection_id, &sender)?;1618            Self::check_white_list(collection_id, &recipient)?;1619        }16201621        match target_collection.mode1622        {1623            CollectionMode::NFT => Self::transfer_nft(collection_id, item_id, sender.clone(), recipient.clone())?,1624            CollectionMode::Fungible(_)  => Self::transfer_fungible(collection_id, value, &sender, &recipient)?,1625            CollectionMode::ReFungible  => Self::transfer_refungible(collection_id, item_id, value, sender.clone(), recipient.clone())?,1626            _ => ()1627        };16281629        Self::deposit_event(RawEvent::Transfer(collection_id, item_id, sender, recipient, value));16301631        Ok(())1632    }163316341635    fn is_correct_transfer(collection_id: CollectionId, collection: &CollectionType<T::AccountId>, recipient: &T::AccountId) -> DispatchResult {16361637        // check token limit and account token limit1638        let account_items: u32 = <AddressTokens<T>>::get(collection_id, recipient).len() as u32;1639        ensure!(collection.limits.account_token_ownership_limit > account_items,  Error::<T>::AccountTokenLimitExceeded);1640        1641        Ok(())1642    }16431644    fn can_create_items_in_collection(collection_id: CollectionId, collection: &CollectionType<T::AccountId>, sender: &T::AccountId, owner: &T::AccountId, amount: u32) -> DispatchResult {16451646        // check token limit and account token limit1647        let total_items: u32 = ItemListIndex::get(collection_id)1648            .checked_add(amount)1649            .ok_or(Error::<T>::CollectionTokenLimitExceeded)?;1650        let account_items: u32 = (<AddressTokens<T>>::get(collection_id, owner).len() as u32)1651            .checked_add(amount)1652            .ok_or(Error::<T>::AccountTokenLimitExceeded)?;1653        ensure!(collection.limits.token_limit >= total_items,  Error::<T>::CollectionTokenLimitExceeded);1654        ensure!(collection.limits.account_token_ownership_limit >= account_items,  Error::<T>::AccountTokenLimitExceeded);16551656        if !Self::is_owner_or_admin_permissions(collection_id, sender.clone()) {1657            ensure!(collection.mint_mode == true, Error::<T>::PublicMintingNotAllowed);1658            Self::check_white_list(collection_id, owner)?;1659            Self::check_white_list(collection_id, sender)?;1660        }16611662        Ok(())1663    }16641665    fn validate_create_item_args(target_collection: &CollectionType<T::AccountId>, data: &CreateItemData) -> DispatchResult {1666        match target_collection.mode1667        {1668            CollectionMode::NFT => {1669                if let CreateItemData::NFT(data) = data {1670                    // check sizes1671                    ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, Error::<T>::TokenConstDataLimitExceeded);1672                    ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);1673                } else {1674                    fail!(Error::<T>::NotNftDataUsedToMintNftCollectionToken);1675                }1676            },1677            CollectionMode::Fungible(_) => {1678                if let CreateItemData::Fungible(_) = data {1679                } else {1680                    fail!(Error::<T>::NotFungibleDataUsedToMintFungibleCollectionToken);1681                }1682            },1683            CollectionMode::ReFungible => {1684                if let CreateItemData::ReFungible(data) = data {16851686                    // check sizes1687                    ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, Error::<T>::TokenConstDataLimitExceeded);1688                    ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);16891690                    // Check refungibility limits1691                    ensure!(data.pieces <= MAX_REFUNGIBLE_PIECES, Error::<T>::WrongRefungiblePieces);1692                    ensure!(data.pieces > 0, Error::<T>::WrongRefungiblePieces);1693                } else {1694                    fail!(Error::<T>::NotReFungibleDataUsedToMintReFungibleCollectionToken);1695                }1696            },1697            _ => { fail!(Error::<T>::UnexpectedCollectionType); }1698        };16991700        Ok(())1701    }17021703    fn create_item_no_validation(collection_id: CollectionId, owner: T::AccountId, data: CreateItemData) -> DispatchResult {1704        match data1705        {1706            CreateItemData::NFT(data) => {1707                let item = NftItemType {1708                    owner: owner.clone(),1709                    const_data: data.const_data,1710                    variable_data: data.variable_data1711                };17121713                Self::add_nft_item(collection_id, item)?;1714            },1715            CreateItemData::Fungible(data) => {1716                Self::add_fungible_item(collection_id, &owner, data.value)?;1717            },1718            CreateItemData::ReFungible(data) => {1719                let mut owner_list = Vec::new();1720                owner_list.push(Ownership {owner: owner.clone(), fraction: data.pieces});17211722                let item = ReFungibleItemType {1723                    owner: owner_list,1724                    const_data: data.const_data,1725                    variable_data: data.variable_data1726                };17271728                Self::add_refungible_item(collection_id, item)?;1729            }1730        };17311732        // call event1733        Self::deposit_event(RawEvent::ItemCreated(collection_id, <ItemListIndex>::get(collection_id), owner));17341735        Ok(())1736    }17371738    fn add_fungible_item(collection_id: CollectionId, owner: &T::AccountId, value: u128) -> DispatchResult {17391740        // Does new owner already have an account?1741        let mut balance: u128 = 0;1742        if <FungibleItemList<T>>::contains_key(collection_id, owner) {1743            balance = <FungibleItemList<T>>::get(collection_id, owner).value;1744        } 17451746        // Mint 1747        let item = FungibleItemType {1748            value: balance + value1749        };1750        <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), item);17511752        // Update balance1753        let new_balance = <Balance<T>>::get(collection_id, owner)1754            .checked_add(value)1755            .ok_or(Error::<T>::NumOverflow)?;1756        <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);17571758        Ok(())1759    }17601761    fn add_refungible_item(collection_id: CollectionId, item: ReFungibleItemType<T::AccountId>) -> DispatchResult {1762        let current_index = <ItemListIndex>::get(collection_id)1763            .checked_add(1)1764            .ok_or(Error::<T>::NumOverflow)?;1765        let itemcopy = item.clone();17661767        let value = item.owner.first().unwrap().fraction;1768        let owner = item.owner.first().unwrap().owner.clone();17691770        Self::add_token_index(collection_id, current_index, &owner)?;17711772        <ItemListIndex>::insert(collection_id, current_index);1773        <ReFungibleItemList<T>>::insert(collection_id, current_index, itemcopy);17741775        // Update balance1776        let new_balance = <Balance<T>>::get(collection_id, &owner)1777            .checked_add(value)1778            .ok_or(Error::<T>::NumOverflow)?;1779        <Balance<T>>::insert(collection_id, owner.clone(), new_balance);17801781        Ok(())1782    }17831784    fn add_nft_item(collection_id: CollectionId, item: NftItemType<T::AccountId>) -> DispatchResult {1785        let current_index = <ItemListIndex>::get(collection_id)1786            .checked_add(1)1787            .ok_or(Error::<T>::NumOverflow)?;17881789        let item_owner = item.owner.clone();1790        Self::add_token_index(collection_id, current_index, &item.owner)?;17911792        <ItemListIndex>::insert(collection_id, current_index);1793        <NftItemList<T>>::insert(collection_id, current_index, item);17941795        // Update balance1796        let new_balance = <Balance<T>>::get(collection_id, item_owner.clone())1797            .checked_add(1)1798            .ok_or(Error::<T>::NumOverflow)?;1799        <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);18001801        Ok(())1802    }18031804    fn burn_refungible_item(1805        collection_id: CollectionId,1806        item_id: TokenId,1807        owner: &T::AccountId,1808    ) -> DispatchResult {1809        ensure!(1810            <ReFungibleItemList<T>>::contains_key(collection_id, item_id),1811            Error::<T>::TokenNotFound1812        );1813        let mut token = <ReFungibleItemList<T>>::get(collection_id, item_id);1814        let rft_balance = token1815            .owner1816            .iter()1817            .filter(|&i| i.owner == *owner)1818            .next()1819            .unwrap();1820        Self::remove_token_index(collection_id, item_id, owner)?;18211822        // update balance1823        let new_balance = <Balance<T>>::get(collection_id, rft_balance.owner.clone())1824            .checked_sub(rft_balance.fraction)1825            .ok_or(Error::<T>::NumOverflow)?;1826        <Balance<T>>::insert(collection_id, rft_balance.owner.clone(), new_balance);18271828        // Re-create owners list with sender removed1829        let index = token1830            .owner1831            .iter()1832            .position(|i| i.owner == *owner)1833            .unwrap();1834        token.owner.remove(index);1835        let owner_count = token.owner.len();18361837        // Burn the token completely if this was the last (only) owner1838        if owner_count == 0 {1839            <ReFungibleItemList<T>>::remove(collection_id, item_id);1840        }1841        else {1842            <ReFungibleItemList<T>>::insert(collection_id, item_id, token);1843        }18441845        Ok(())1846    }18471848    fn burn_nft_item(collection_id: CollectionId, item_id: TokenId) -> DispatchResult {1849        ensure!(1850            <NftItemList<T>>::contains_key(collection_id, item_id),1851            Error::<T>::TokenNotFound1852        );1853        let item = <NftItemList<T>>::get(collection_id, item_id);1854        Self::remove_token_index(collection_id, item_id, &item.owner)?;18551856        // update balance1857        let new_balance = <Balance<T>>::get(collection_id, &item.owner)1858            .checked_sub(1)1859            .ok_or(Error::<T>::NumOverflow)?;1860        <Balance<T>>::insert(collection_id, item.owner.clone(), new_balance);1861        <NftItemList<T>>::remove(collection_id, item_id);18621863        Ok(())1864    }18651866    fn burn_fungible_item(owner: &T::AccountId, collection_id: CollectionId, value: u128) -> DispatchResult {1867        ensure!(1868            <FungibleItemList<T>>::contains_key(collection_id, owner),1869            Error::<T>::TokenNotFound1870        );1871        let mut balance = <FungibleItemList<T>>::get(collection_id, owner);1872        ensure!(balance.value >= value, Error::<T>::TokenValueNotEnough);18731874        // update balance1875        let new_balance = <Balance<T>>::get(collection_id, owner)1876            .checked_sub(value)1877            .ok_or(Error::<T>::NumOverflow)?;1878        <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);18791880        if balance.value - value > 0 {1881            balance.value -= value;1882            <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), balance);1883        }1884        else {1885            <FungibleItemList<T>>::remove(collection_id, owner);1886        }18871888        Ok(())1889    }18901891    fn collection_exists(collection_id: CollectionId) -> DispatchResult {1892        ensure!(1893            <Collection<T>>::contains_key(collection_id),1894            Error::<T>::CollectionNotFound1895        );1896        Ok(())1897    }18981899    fn check_owner_permissions(collection_id: CollectionId, subject: T::AccountId) -> DispatchResult {1900        Self::collection_exists(collection_id)?;19011902        let target_collection = <Collection<T>>::get(collection_id);1903        ensure!(1904            subject == target_collection.owner,1905            Error::<T>::NoPermission1906        );19071908        Ok(())1909    }19101911    fn is_owner_or_admin_permissions(collection_id: CollectionId, subject: T::AccountId) -> bool {1912        let target_collection = <Collection<T>>::get(collection_id);1913        let mut result: bool = subject == target_collection.owner;1914        let exists = <AdminList<T>>::contains_key(collection_id);19151916        if !result & exists {1917            if <AdminList<T>>::get(collection_id).contains(&subject) {1918                result = true1919            }1920        }19211922        result1923    }19241925    fn check_owner_or_admin_permissions(1926        collection_id: CollectionId,1927        subject: T::AccountId,1928    ) -> DispatchResult {1929        Self::collection_exists(collection_id)?;1930        let result = Self::is_owner_or_admin_permissions(collection_id, subject.clone());19311932        ensure!(1933            result,1934            Error::<T>::NoPermission1935        );1936        Ok(())1937    }19381939    fn owned_amount(1940        subject: T::AccountId,1941        collection_id: CollectionId,1942        item_id: TokenId,1943    ) -> Option<u128> {1944        let target_collection = <Collection<T>>::get(collection_id);19451946        match target_collection.mode {1947            CollectionMode::NFT => {1948                if <NftItemList<T>>::get(collection_id, item_id).owner == subject {1949                    return Some(1)1950                }1951                None1952            },1953            CollectionMode::Fungible(_) => {1954                if <FungibleItemList<T>>::contains_key(collection_id, &subject) {1955                    return Some(<FungibleItemList<T>>::get(collection_id, &subject)1956                        .value);1957                }1958                None1959            },1960            CollectionMode::ReFungible => <ReFungibleItemList<T>>::get(collection_id, item_id)1961                .owner1962                .iter()1963                .find(|i| i.owner == subject)1964                .map(|i| i.fraction),1965            CollectionMode::Invalid => None,1966        }1967    }19681969    fn is_item_owner(subject: T::AccountId, collection_id: CollectionId, item_id: TokenId) -> bool {1970        let target_collection = <Collection<T>>::get(collection_id);19711972        match target_collection.mode {1973            CollectionMode::NFT => {1974                <NftItemList<T>>::get(collection_id, item_id).owner == subject1975            }1976            CollectionMode::Fungible(_) => {1977                <FungibleItemList<T>>::contains_key(collection_id, &subject)1978            }1979            CollectionMode::ReFungible => {1980                <ReFungibleItemList<T>>::get(collection_id, item_id)1981                    .owner1982                    .iter()1983                    .any(|i| i.owner == subject)1984            }1985            CollectionMode::Invalid => false,1986        }1987    }19881989    fn check_white_list(collection_id: CollectionId, address: &T::AccountId) -> DispatchResult {1990        let mes = Error::<T>::AddresNotInWhiteList;1991        ensure!(<WhiteList<T>>::contains_key(collection_id, address), mes);19921993        Ok(())1994    }19951996    /// Check if token exists. In case of Fungible, check if there is an entry for 1997    /// the owner in fungible balances double map1998    fn token_exists(1999        collection_id: CollectionId,2000        item_id: TokenId,2001        owner: &T::AccountId2002    ) -> DispatchResult {2003        let target_collection = <Collection<T>>::get(collection_id);2004        let exists = match target_collection.mode2005        {2006            CollectionMode::NFT => <NftItemList<T>>::contains_key(collection_id, item_id),2007            CollectionMode::Fungible(_)  => <FungibleItemList<T>>::contains_key(collection_id, owner),2008            CollectionMode::ReFungible  => <ReFungibleItemList<T>>::contains_key(collection_id, item_id),2009            _ => false2010        };20112012        ensure!(exists == true, Error::<T>::TokenNotFound);2013        Ok(())2014    }20152016    fn transfer_fungible(2017        collection_id: CollectionId,2018        value: u128,2019        owner: &T::AccountId,2020        recipient: &T::AccountId,2021    ) -> DispatchResult {2022        Self::token_exists(collection_id, 0, owner)?;20232024        let mut balance = <FungibleItemList<T>>::get(collection_id, owner);2025        ensure!(balance.value >= value, Error::<T>::TokenValueTooLow);20262027        // Send balance to recipient (updates balanceOf of recipient)2028        Self::add_fungible_item(collection_id, recipient, value)?;20292030        // update balanceOf of sender2031        <Balance<T>>::insert(collection_id, (*owner).clone(), balance.value - value);20322033        // Reduce or remove sender2034        if balance.value == value {2035            <FungibleItemList<T>>::remove(collection_id, owner);2036        }2037        else {2038            balance.value -= value;2039            <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), balance);2040        }20412042        Ok(())2043    }20442045    fn transfer_refungible(2046        collection_id: CollectionId,2047        item_id: TokenId,2048        value: u128,2049        owner: T::AccountId,2050        new_owner: T::AccountId,2051    ) -> DispatchResult {2052        Self::token_exists(collection_id, item_id, &owner)?;20532054        let full_item = <ReFungibleItemList<T>>::get(collection_id, item_id);2055        let item = full_item2056            .owner2057            .iter()2058            .filter(|i| i.owner == owner)2059            .next()2060            .ok_or(Error::<T>::NumOverflow)?;2061        let amount = item.fraction;20622063        ensure!(amount >= value, Error::<T>::TokenValueTooLow);20642065        // update balance2066        let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())2067            .checked_sub(value)2068            .ok_or(Error::<T>::NumOverflow)?;2069        <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);20702071        let balancenew_owner = <Balance<T>>::get(collection_id, new_owner.clone())2072            .checked_add(value)2073            .ok_or(Error::<T>::NumOverflow)?;2074        <Balance<T>>::insert(collection_id, new_owner.clone(), balancenew_owner);20752076        let old_owner = item.owner.clone();2077        let new_owner_has_account = full_item.owner.iter().any(|i| i.owner == new_owner);20782079        // transfer2080        if amount == value && !new_owner_has_account {2081            // change owner2082            // new owner do not have account2083            let mut new_full_item = full_item.clone();2084            new_full_item2085                .owner2086                .iter_mut()2087                .find(|i| i.owner == owner)2088                .unwrap()2089                .owner = new_owner.clone();2090            <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);20912092            // update index collection2093            Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;2094        } else {2095            let mut new_full_item = full_item.clone();2096            new_full_item2097                .owner2098                .iter_mut()2099                .find(|i| i.owner == owner)2100                .unwrap()2101                .fraction -= value;21022103            // separate amount2104            if new_owner_has_account {2105                // new owner has account2106                new_full_item2107                    .owner2108                    .iter_mut()2109                    .find(|i| i.owner == new_owner)2110                    .unwrap()2111                    .fraction += value;2112            } else {2113                // new owner do not have account2114                new_full_item.owner.push(Ownership {2115                    owner: new_owner.clone(),2116                    fraction: value,2117                });2118                Self::add_token_index(collection_id, item_id, &new_owner)?;2119            }21202121            <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);2122        }21232124        Ok(())2125    }21262127    fn transfer_nft(2128        collection_id: CollectionId,2129        item_id: TokenId,2130        sender: T::AccountId,2131        new_owner: T::AccountId,2132    ) -> DispatchResult {2133        Self::token_exists(collection_id, item_id, &sender)?;21342135        let mut item = <NftItemList<T>>::get(collection_id, item_id);21362137        ensure!(2138            sender == item.owner,2139            Error::<T>::MustBeTokenOwner2140        );21412142        // update balance2143        let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())2144            .checked_sub(1)2145            .ok_or(Error::<T>::NumOverflow)?;2146        <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);21472148        let balancenew_owner = <Balance<T>>::get(collection_id, new_owner.clone())2149            .checked_add(1)2150            .ok_or(Error::<T>::NumOverflow)?;2151        <Balance<T>>::insert(collection_id, new_owner.clone(), balancenew_owner);21522153        // change owner2154        let old_owner = item.owner.clone();2155        item.owner = new_owner.clone();2156        <NftItemList<T>>::insert(collection_id, item_id, item);21572158        // update index collection2159        Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;21602161        Ok(())2162    }2163    2164    fn set_re_fungible_variable_data(2165        collection_id: CollectionId,2166        item_id: TokenId,2167        data: Vec<u8>2168    ) -> DispatchResult {2169        let mut item = <ReFungibleItemList<T>>::get(collection_id, item_id);21702171        item.variable_data = data;21722173        <ReFungibleItemList<T>>::insert(collection_id, item_id, item);21742175        Ok(())2176    }21772178    fn set_nft_variable_data(2179        collection_id: CollectionId,2180        item_id: TokenId,2181        data: Vec<u8>2182    ) -> DispatchResult {2183        let mut item = <NftItemList<T>>::get(collection_id, item_id);2184        2185        item.variable_data = data;21862187        <NftItemList<T>>::insert(collection_id, item_id, item);2188        2189        Ok(())2190    }21912192    fn init_collection(item: &CollectionType<T::AccountId>) {2193        // check params2194        assert!(2195            item.decimal_points <= MAX_DECIMAL_POINTS,2196            "decimal_points parameter must be lower than MAX_DECIMAL_POINTS"2197        );2198        assert!(2199            item.name.len() <= 64,2200            "Collection name can not be longer than 63 char"2201        );2202        assert!(2203            item.name.len() <= 256,2204            "Collection description can not be longer than 255 char"2205        );2206        assert!(2207            item.token_prefix.len() <= 16,2208            "Token prefix can not be longer than 15 char"2209        );22102211        // Generate next collection ID2212        let next_id = CreatedCollectionCount::get()2213            .checked_add(1)2214            .unwrap();22152216        CreatedCollectionCount::put(next_id);2217    }22182219    fn init_nft_token(collection_id: CollectionId, item: &NftItemType<T::AccountId>) {2220        let current_index = <ItemListIndex>::get(collection_id)2221            .checked_add(1)2222            .unwrap();22232224        let item_owner = item.owner.clone();2225        Self::add_token_index(collection_id, current_index, &item.owner).unwrap();22262227        <ItemListIndex>::insert(collection_id, current_index);22282229        // Update balance2230        let new_balance = <Balance<T>>::get(collection_id, &item_owner)2231            .checked_add(1)2232            .unwrap();2233        <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);2234    }22352236    fn init_fungible_token(collection_id: CollectionId, owner: &T::AccountId, item: &FungibleItemType) {2237        let current_index = <ItemListIndex>::get(collection_id)2238            .checked_add(1)2239            .unwrap();22402241        Self::add_token_index(collection_id, current_index, owner).unwrap();22422243        <ItemListIndex>::insert(collection_id, current_index);22442245        // Update balance2246        let new_balance = <Balance<T>>::get(collection_id, owner)2247            .checked_add(item.value)2248            .unwrap();2249        <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);2250    }22512252    fn init_refungible_token(collection_id: CollectionId, item: &ReFungibleItemType<T::AccountId>) {2253        let current_index = <ItemListIndex>::get(collection_id)2254            .checked_add(1)2255            .unwrap();22562257        let value = item.owner.first().unwrap().fraction;2258        let owner = item.owner.first().unwrap().owner.clone();22592260        Self::add_token_index(collection_id, current_index, &owner).unwrap();22612262        <ItemListIndex>::insert(collection_id, current_index);22632264        // Update balance2265        let new_balance = <Balance<T>>::get(collection_id, &owner)2266            .checked_add(value)2267            .unwrap();2268        <Balance<T>>::insert(collection_id, owner.clone(), new_balance);2269    }22702271    fn add_token_index(collection_id: CollectionId, item_index: TokenId, owner: &T::AccountId) -> DispatchResult {22722273        // add to account limit2274        if <AccountItemCount<T>>::contains_key(owner) {22752276            // bound Owned tokens by a single address2277            let count = <AccountItemCount<T>>::get(owner);2278            ensure!(count < ChainLimit::get().account_token_ownership_limit, Error::<T>::AddressOwnershipLimitExceeded);22792280            <AccountItemCount<T>>::insert(owner.clone(), count2281                .checked_add(1)2282                .ok_or(Error::<T>::NumOverflow)?);2283        }2284        else {2285            <AccountItemCount<T>>::insert(owner.clone(), 1);2286        }22872288        let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner);2289        if list_exists {2290            let mut list = <AddressTokens<T>>::get(collection_id, owner);2291            let item_contains = list.contains(&item_index.clone());22922293            if !item_contains {2294                list.push(item_index.clone());2295            }22962297            <AddressTokens<T>>::insert(collection_id, owner.clone(), list);2298        } else {2299            let mut itm = Vec::new();2300            itm.push(item_index.clone());2301            <AddressTokens<T>>::insert(collection_id, owner.clone(), itm);2302        }23032304        Ok(())2305    }23062307    fn remove_token_index(2308        collection_id: CollectionId,2309        item_index: TokenId,2310        owner: &T::AccountId,2311    ) -> DispatchResult {23122313        // update counter2314        <AccountItemCount<T>>::insert(owner.clone(), 2315            <AccountItemCount<T>>::get(owner)2316            .checked_sub(1)2317            .ok_or(Error::<T>::NumOverflow)?);231823192320        let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner);2321        if list_exists {2322            let mut list = <AddressTokens<T>>::get(collection_id, owner);2323            let item_contains = list.contains(&item_index.clone());23242325            if item_contains {2326                list.retain(|&item| item != item_index);2327                <AddressTokens<T>>::insert(collection_id, owner.clone(), list);2328            }2329        }23302331        Ok(())2332    }23332334    fn move_token_index(2335        collection_id: CollectionId,2336        item_index: TokenId,2337        old_owner: &T::AccountId,2338        new_owner: &T::AccountId,2339    ) -> DispatchResult {2340        Self::remove_token_index(collection_id, item_index, old_owner)?;2341        Self::add_token_index(collection_id, item_index, new_owner)?;23422343        Ok(())2344    }2345    2346    fn ensure_contract_owned(account: T::AccountId, contract: &T::AccountId) -> DispatchResult {2347        if <ContractOwner<T>>::contains_key(contract.clone()) {2348            let owner = <ContractOwner<T>>::get(contract);2349            ensure!(account == owner, Error::<T>::NoPermission);2350        } else {2351            fail!(Error::<T>::NoPermission);2352        }23532354        Ok(())2355    }2356}23572358////////////////////////////////////////////////////////////////////////////////////////////////////2359// Economic models2360// #region23612362/// Fee multiplier.2363pub type Multiplier = FixedU128;23642365type BalanceOf<T> = <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::Balance;23662367/// Require the transactor pay for themselves and maybe include a tip to gain additional priority2368/// in the queue.2369#[derive(Encode, Decode, Clone, Eq, PartialEq)]2370pub struct ChargeTransactionPayment<T: Config>(#[codec(compact)] BalanceOf<T>);23712372impl<T: Config + Send + Sync> sp_std::fmt::Debug 2373    for ChargeTransactionPayment<T>2374{2375	#[cfg(feature = "std")]2376	fn fmt(&self, f: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {2377		write!(f, "ChargeTransactionPayment<{:?}>", self.0)2378	}2379	#[cfg(not(feature = "std"))]2380	fn fmt(&self, _: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {2381		Ok(())2382	}2383}23842385impl<T: Config> ChargeTransactionPayment<T>2386where2387    T::Call: Dispatchable<Info=DispatchInfo, PostInfo=PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,2388    BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,2389    T::AccountId: AsRef<[u8]>,2390    T::AccountId: UncheckedFrom<T::Hash>,2391{2392    fn traditional_fee(2393        len: usize,2394        info: &DispatchInfoOf<T::Call>,2395        tip: BalanceOf<T>,2396    ) -> BalanceOf<T>2397    where2398        T::Call: Dispatchable<Info = DispatchInfo>,2399    {2400        <pallet_transaction_payment::Module<T>>::compute_fee(len as u32, info, tip)2401    }24022403	fn get_priority(len: usize, info: &DispatchInfoOf<T::Call>, final_fee: BalanceOf<T>) -> TransactionPriority {2404        let weight_saturation = T::BlockWeights::get().max_block / info.weight.max(1);2405        let max_block_length = *T::BlockLength::get().max.get(DispatchClass::Normal);2406        let len_saturation = max_block_length as u64 / (len as u64).max(1);2407        let coefficient: BalanceOf<T> = weight_saturation2408            .min(len_saturation)2409            .saturated_into::<BalanceOf<T>>();2410        final_fee2411            .saturating_mul(coefficient)2412            .saturated_into::<TransactionPriority>()2413    }24142415    fn withdraw_fee(2416        &self,2417        who: &T::AccountId,2418        call: &T::Call,2419        info: &DispatchInfoOf<T::Call>,2420        len: usize,2421	) -> Result<2422		(2423			BalanceOf<T>,2424			<<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::LiquidityInfo,2425		),2426		TransactionValidityError,2427	> {2428        let tip = self.0;24292430        // Set fee based on call type. Creating collection costs 1 Unique.2431        // All other transactions have traditional fees so far2432        // let fee = match call.is_sub_type() {2433        //     Some(Call::create_collection(..)) => <BalanceOf<T>>::from(1_000_000_000),2434        //     _ => Self::traditional_fee(len, info, tip), // Flat fee model, use only for testing purposes2435        //                                                 // _ => <BalanceOf<T>>::from(100)2436        // };2437        let fee = Self::traditional_fee(len, info, tip);24382439        // Only mess with balances if fee is not zero.2440        if fee.is_zero() {2441            return <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::withdraw_fee(who, call, info, fee, tip)2442			.map(|i| (fee, i));2443        }24442445        // Determine who is paying transaction fee based on ecnomic model2446        // Parse call to extract collection ID and access collection sponsor2447        let mut sponsor: T::AccountId = match IsSubType::<Call<T>>::is_sub_type(call) {2448            Some(Call::create_item(collection_id, _owner, _properties)) => {24492450                // sponsor timeout2451                let block_number = <system::Module<T>>::block_number() as T::BlockNumber;24522453                let limit = <Collection<T>>::get(collection_id).limits.sponsor_transfer_timeout;2454                let mut sponsored = true;2455                if <CreateItemBasket<T>>::contains_key((collection_id, &who)) {2456                    let last_tx_block = <CreateItemBasket<T>>::get((collection_id, &who));2457                    let limit_time = last_tx_block + limit.into();2458                    if block_number <= limit_time {2459                        sponsored = false;2460                    }2461                }2462                if sponsored {2463                    <CreateItemBasket<T>>::insert((collection_id, who.clone()), block_number);2464                }24652466                // check free create limit2467                if (<Collection<T>>::get(collection_id).limits.sponsored_data_size >= (_properties.len() as u32)) &&2468                   (<Collection<T>>::get(collection_id).sponsor_confirmed) &&2469                   (sponsored)2470                {2471                    <Collection<T>>::get(collection_id).sponsor2472                } else {2473                    T::AccountId::default()2474                }2475            }2476            Some(Call::transfer(_new_owner, collection_id, item_id, _value)) => {2477                2478                let mut sponsor_transfer = false;2479                if <Collection<T>>::get(collection_id).sponsor_confirmed {24802481                    let collection_limits = <Collection<T>>::get(collection_id).limits;2482                    let collection_mode = <Collection<T>>::get(collection_id).mode;2483    2484                    // sponsor timeout2485                    let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2486                    sponsor_transfer = match collection_mode {2487                        CollectionMode::NFT => {2488    2489                            // get correct limit2490                            let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2491                                collection_limits.sponsor_transfer_timeout2492                            } else {2493                                ChainLimit::get().nft_sponsor_transfer_timeout2494                            };2495    2496                            let mut sponsored = true;2497                            if <NftTransferBasket<T>>::contains_key(collection_id, item_id) {2498                                let last_tx_block = <NftTransferBasket<T>>::get(collection_id, item_id);2499                                let limit_time = last_tx_block + limit.into();2500                                if block_number <= limit_time {2501                                    sponsored = false;2502                                }2503                            }2504                            if sponsored {2505                                <NftTransferBasket<T>>::insert(collection_id, item_id, block_number);2506                            }25072508                            sponsored2509                        }2510                        CollectionMode::Fungible(_) => {2511    2512                            // get correct limit2513                            let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2514                                collection_limits.sponsor_transfer_timeout2515                            } else {2516                                ChainLimit::get().fungible_sponsor_transfer_timeout2517                            };2518    2519                            let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2520                            let mut sponsored = true;2521                            if <FungibleTransferBasket<T>>::contains_key(collection_id, who) {2522                                let last_tx_block = <FungibleTransferBasket<T>>::get(collection_id, who);2523                                let limit_time = last_tx_block + limit.into();2524                                if block_number <= limit_time {2525                                    sponsored = false;2526                                }2527                            }2528                            if sponsored {2529                                <FungibleTransferBasket<T>>::insert(collection_id, who, block_number);2530                            }25312532                            sponsored2533                        }2534                        CollectionMode::ReFungible => {2535    2536                            // get correct limit2537                            let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2538                                collection_limits.sponsor_transfer_timeout2539                            } else {2540                                ChainLimit::get().refungible_sponsor_transfer_timeout2541                            };2542    2543                            let mut sponsored = true;2544                            if <ReFungibleTransferBasket<T>>::contains_key(collection_id, item_id) {2545                                let last_tx_block = <ReFungibleTransferBasket<T>>::get(collection_id, item_id);2546                                let limit_time = last_tx_block + limit.into();2547                                if block_number <= limit_time {2548                                    sponsored = false;2549                                }2550                            }2551                            if sponsored {2552                                <ReFungibleTransferBasket<T>>::insert(collection_id, item_id, block_number);2553                            }25542555                            sponsored2556                        }2557                        _ => {2558                            false2559                        },2560                    };2561                }25622563                if !sponsor_transfer {2564                    T::AccountId::default()2565                } else {2566                    <Collection<T>>::get(collection_id).sponsor2567                }2568            }25692570            _ => T::AccountId::default(),2571        };25722573        // Sponsor smart contracts2574        sponsor = match IsSubType::<pallet_contracts::Call<T>>::is_sub_type(call) {25752576            // On instantiation: set the contract owner2577            Some(pallet_contracts::Call::instantiate(_endowment, _gas_limit, code_hash, _data, salt)) => {25782579                let new_contract_address = <pallet_contracts::Module<T>>::contract_address(2580                    &who,2581                    code_hash,2582                    salt,2583                );2584                <ContractOwner<T>>::insert(new_contract_address.clone(), who.clone());25852586                T::AccountId::default()2587            },25882589            // On instantiation with code: set the contract owner2590            Some(pallet_contracts::Call::instantiate_with_code(_endowment, _gas_limit, _code, _data, _salt))  => {25912592                let new_contract_address = <pallet_contracts::Module<T>>::contract_address(2593                    &who,2594                    &T::Hashing::hash(&_code),2595                    _salt,2596                );25972598                <ContractOwner<T>>::insert(new_contract_address.clone(), who.clone());25992600                T::AccountId::default()2601            }26022603            // When the contract is called, check if the sponsoring is enabled and pay fees from contract endowment if it is2604            Some(pallet_contracts::Call::call(dest, _value, _gas_limit, _data)) => {26052606                let called_contract: T::AccountId = T::Lookup::lookup((*dest).clone()).unwrap_or(T::AccountId::default());26072608                let owned_contract = <ContractOwner<T>>::contains_key(called_contract.clone())2609                  && <ContractOwner<T>>::get(called_contract.clone()) == *who;2610                let white_list_enabled = <ContractWhiteListEnabled<T>>::contains_key(called_contract.clone()) && <ContractWhiteListEnabled<T>>::get(called_contract.clone());2611                  2612                if !owned_contract && white_list_enabled {2613                    if !<ContractWhiteList<T>>::contains_key(called_contract.clone(), who) {2614                        return Err(InvalidTransaction::Call.into());2615                    }2616                }26172618                let mut sponsor_transfer = false;2619                if <ContractSponsoringRateLimit<T>>::contains_key(called_contract.clone()) {2620                    let last_tx_block = <ContractSponsorBasket<T>>::get((&called_contract, &who));2621                    let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2622                    let rate_limit = <ContractSponsoringRateLimit<T>>::get(&called_contract);2623                    let limit_time = last_tx_block + rate_limit;26242625                    if block_number >= limit_time {2626                        <ContractSponsorBasket<T>>::insert((called_contract.clone(), who.clone()), block_number);2627                        sponsor_transfer = true;2628                    }2629                } else {2630                    sponsor_transfer = false;2631                }2632               2633                2634                let mut sp = T::AccountId::default();2635                if sponsor_transfer {2636                    if <ContractSelfSponsoring<T>>::contains_key(called_contract.clone()) {2637                        if <ContractSelfSponsoring<T>>::get(called_contract.clone()) {2638                            sp = called_contract;2639                        }2640                    }2641                }26422643                sp2644            },26452646            _ => sponsor,2647        };26482649        let mut who_pays_fee: T::AccountId = sponsor.clone();2650        if sponsor == T::AccountId::default() {2651            who_pays_fee = who.clone();2652        }26532654		<<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::withdraw_fee(&who_pays_fee, call, info, fee, tip)2655			.map(|i| (fee, i))2656    }2657}265826592660impl<T: Config + Send + Sync> SignedExtension2661    for ChargeTransactionPayment<T>2662where2663    BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,2664    T::Call: Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,2665    T::AccountId: AsRef<[u8]>,2666    T::AccountId: UncheckedFrom<T::Hash>,2667{2668    const IDENTIFIER: &'static str = "ChargeTransactionPayment";2669    type AccountId = T::AccountId;2670    type Call = T::Call;2671    type AdditionalSigned = ();2672    type Pre = (2673        // tip2674        BalanceOf<T>,2675        // who pays fee2676        Self::AccountId,2677		// imbalance resulting from withdrawing the fee2678		<<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::LiquidityInfo,2679    );2680    fn additional_signed(&self) -> sp_std::result::Result<(), TransactionValidityError> {2681        Ok(())2682    }26832684    fn validate(2685        &self,2686        who: &Self::AccountId,2687        call: &Self::Call,2688        info: &DispatchInfoOf<Self::Call>,2689        len: usize,2690    ) -> TransactionValidity {2691		let (fee, _) = self.withdraw_fee(who, call, info, len)?;2692		Ok(ValidTransaction {2693			priority: Self::get_priority(len, info, fee),2694			..Default::default()2695		})2696    }26972698    fn pre_dispatch(2699        self,2700        who: &Self::AccountId,2701        call: &Self::Call,2702        info: &DispatchInfoOf<Self::Call>,2703        len: usize,2704    ) -> Result<Self::Pre, TransactionValidityError> {2705        let (_fee, imbalance) = self.withdraw_fee(who, call, info, len)?;2706        Ok((self.0, who.clone(), imbalance))2707    }27082709    fn post_dispatch(2710        pre: Self::Pre,2711        info: &DispatchInfoOf<Self::Call>,2712        post_info: &PostDispatchInfoOf<Self::Call>,2713        len: usize,2714        _result: &DispatchResult,2715    ) -> Result<(), TransactionValidityError> {2716		let (tip, who, imbalance) = pre;2717		let actual_fee = pallet_transaction_payment::Module::<T>::compute_actual_fee(2718			len as u32,2719			info,2720			post_info,2721			tip,2722		);2723		<T as pallet_transaction_payment::Config>::OnChargeTransaction::correct_and_deposit_fee(&who, info, post_info, actual_fee, tip, imbalance)?;2724		Ok(())2725    }2726}27272728// #endregion