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

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        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 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_value(), 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        /// Schema data size limit bound exceeded386        SchemaDataLimitExceeded,387        /// Maximum refungibility exceeded388        WrongRefungiblePieces389	}390}391392pub trait Config: system::Config + Sized + transaction_payment::Config + pallet_contracts::Config {393    type Event: From<Event<Self>> + Into<<Self as system::Config>::Event>;394395    /// Weight information for extrinsics in this pallet.396	type WeightInfo: WeightInfo;397}398399#[cfg(feature = "runtime-benchmarks")]400mod benchmarking;401402// #endregion403404decl_storage! {405    trait Store for Module<T: Config> as Nft {406407        // Private members408        NextCollectionID: CollectionId;409        CreatedCollectionCount: u32;410        ChainVersion: u64;411        ItemListIndex: map hasher(identity) CollectionId => TokenId;412413        // Chain limits struct414        pub ChainLimit get(fn chain_limit) config(): ChainLimits;415416        // Bound counters417        CollectionCount: u32;418        pub AccountItemCount get(fn account_item_count): map hasher(twox_64_concat) T::AccountId => u32;419420        // Basic collections421        pub Collection get(fn collection) config(): map hasher(identity) CollectionId => CollectionType<T::AccountId>;422        pub AdminList get(fn admin_list_collection): map hasher(identity) CollectionId => Vec<T::AccountId>;423        pub WhiteList get(fn white_list): double_map hasher(identity) CollectionId, hasher(twox_64_concat) T::AccountId => bool;424425        /// Balance owner per collection map426        pub Balance get(fn balance_count): double_map hasher(identity) CollectionId, hasher(twox_64_concat) T::AccountId => u128;427428        /// second parameter: item id + owner account id + spender account id429        pub Allowances get(fn approved): double_map hasher(identity) CollectionId, hasher(twox_64_concat) (TokenId, T::AccountId, T::AccountId) => u128;430431        /// Item collections432        pub NftItemList get(fn nft_item_id) config(): double_map hasher(identity) CollectionId, hasher(identity) TokenId => NftItemType<T::AccountId>;433        pub FungibleItemList get(fn fungible_item_id) config(): double_map hasher(identity) CollectionId, hasher(twox_64_concat) T::AccountId => FungibleItemType;434        pub ReFungibleItemList get(fn refungible_item_id) config(): double_map hasher(identity) CollectionId, hasher(identity) TokenId => ReFungibleItemType<T::AccountId>;435436        /// Index list437        pub AddressTokens get(fn address_tokens): double_map hasher(identity) CollectionId, hasher(twox_64_concat) T::AccountId => Vec<TokenId>;438439        /// Tokens transfer baskets440        pub CreateItemBasket get(fn create_item_basket): map hasher(twox_64_concat) (CollectionId, T::AccountId) => T::BlockNumber;441        pub NftTransferBasket get(fn nft_transfer_basket): double_map hasher(identity) CollectionId, hasher(identity) TokenId => T::BlockNumber;442        pub FungibleTransferBasket get(fn fungible_transfer_basket): double_map hasher(identity) CollectionId, hasher(twox_64_concat) T::AccountId => T::BlockNumber;443        pub ReFungibleTransferBasket get(fn refungible_transfer_basket): double_map hasher(identity) CollectionId, hasher(identity) TokenId => T::BlockNumber;444445        // Contract Sponsorship and Ownership446        pub ContractOwner get(fn contract_owner): map hasher(twox_64_concat) T::AccountId => T::AccountId;447        pub ContractSelfSponsoring get(fn contract_self_sponsoring): map hasher(twox_64_concat) T::AccountId => bool;448        pub ContractSponsorBasket get(fn contract_sponsor_basket): map hasher(twox_64_concat) (T::AccountId, T::AccountId) => T::BlockNumber;449        pub ContractSponsoringRateLimit get(fn contract_sponsoring_rate_limit): map hasher(twox_64_concat) T::AccountId => T::BlockNumber;450        pub ContractWhiteListEnabled get(fn contract_white_list_enabled): map hasher(twox_64_concat) T::AccountId => bool; 451        pub ContractWhiteList get(fn contract_white_list): double_map hasher(twox_64_concat) T::AccountId, hasher(twox_64_concat) T::AccountId => bool; 452    }453    add_extra_genesis {454        build(|config: &GenesisConfig<T>| {455            // Modification of storage456            for (_num, _c) in &config.collection {457                <Module<T>>::init_collection(_c);458            }459460            for (_num, _c, _i) in &config.nft_item_id {461                <Module<T>>::init_nft_token(*_c, _i);462            }463464            for (collection_id, account_id, fungible_item) in &config.fungible_item_id {465                <Module<T>>::init_fungible_token(*collection_id, account_id, fungible_item);466            }467468            for (_num, _c, _i) in &config.refungible_item_id {469                <Module<T>>::init_refungible_token(*_c, _i);470            }471        })472    }473}474475decl_event!(476    pub enum Event<T>477    where478        AccountId = <T as system::Config>::AccountId,479    {480        /// New collection was created481        /// 482        /// # Arguments483        /// 484        /// * collection_id: Globally unique identifier of newly created collection.485        /// 486        /// * mode: [CollectionMode] converted into u8.487        /// 488        /// * account_id: Collection owner.489        Created(CollectionId, u8, AccountId),490491        /// New item was created.492        /// 493        /// # Arguments494        /// 495        /// * collection_id: Id of the collection where item was created.496        /// 497        /// * item_id: Id of an item. Unique within the collection.498        ///499        /// * recipient: Owner of newly created item 500        ItemCreated(CollectionId, TokenId, AccountId),501502        /// Collection item was burned.503        /// 504        /// # Arguments505        /// 506        /// collection_id.507        /// 508        /// item_id: Identifier of burned NFT.509        ItemDestroyed(CollectionId, TokenId),510    }511);512513decl_module! {514    pub struct Module<T: Config> for enum Call 515    where 516        origin: T::Origin517    {518        fn deposit_event() = default;519        type Error = Error<T>;520521        fn on_initialize(now: T::BlockNumber) -> Weight {522523            if ChainVersion::get() < 2524            {525                let value = NextCollectionID::get();526                CreatedCollectionCount::put(value);527                ChainVersion::put(2);528            }529530            0531        }532533        /// 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.534        /// 535        /// # Permissions536        /// 537        /// * Anyone.538        /// 539        /// # Arguments540        /// 541        /// * collection_name: UTF-16 string with collection name (limit 64 characters), will be stored as zero-terminated.542        /// 543        /// * collection_description: UTF-16 string with collection description (limit 256 characters), will be stored as zero-terminated.544        /// 545        /// * token_prefix: UTF-8 string with token prefix.546        /// 547        /// * mode: [CollectionMode] collection type and type dependent data.548        // returns collection ID549        #[weight = <T as Config>::WeightInfo::create_collection()]550        pub fn create_collection(origin,551                                 collection_name: Vec<u16>,552                                 collection_description: Vec<u16>,553                                 token_prefix: Vec<u8>,554                                 mode: CollectionMode) -> DispatchResult {555556            // Anyone can create a collection557            let who = ensure_signed(origin)?;558559            let decimal_points = match mode {560                CollectionMode::Fungible(points) => points,561                _ => 0562            };563564            // bound Total number of collections565            ensure!(CollectionCount::get() < ChainLimit::get().collection_numbers_limit, Error::<T>::TotalCollectionsLimitExceeded);566567            // check params568            ensure!(decimal_points <= MAX_DECIMAL_POINTS, Error::<T>::CollectionDecimalPointLimitExceeded);569            ensure!(collection_name.len() <= 64, Error::<T>::CollectionNameLimitExceeded);570            ensure!(collection_description.len() <= 256, Error::<T>::CollectionDescriptionLimitExceeded);571            ensure!(token_prefix.len() <= 16, Error::<T>::CollectionTokenPrefixLimitExceeded);572573            // Generate next collection ID574            let next_id = CreatedCollectionCount::get()575                .checked_add(1)576                .ok_or(Error::<T>::NumOverflow)?;577578            // bound counter579            let total = CollectionCount::get()580                .checked_add(1)581                .ok_or(Error::<T>::NumOverflow)?;582583            CreatedCollectionCount::put(next_id);584            CollectionCount::put(total);585586            // Create new collection587            let new_collection = CollectionType {588                owner: who.clone(),589                name: collection_name,590                mode: mode.clone(),591                mint_mode: false,592                access: AccessMode::Normal,593                description: collection_description,594                decimal_points: decimal_points,595                token_prefix: token_prefix,596                offchain_schema: Vec::new(),597                schema_version: SchemaVersion::ImageURL,598                sponsor: T::AccountId::default(),599                sponsor_confirmed: false,600                variable_on_chain_schema: Vec::new(),601                const_on_chain_schema: Vec::new(),602                limits: CollectionLimits::default()603            };604605            // Add new collection to map606            <Collection<T>>::insert(next_id, new_collection);607608            // call event609            Self::deposit_event(RawEvent::Created(next_id, mode.into(), who.clone()));610611            Ok(())612        }613614        /// **DANGEROUS**: Destroys collection and all NFTs within this collection. Users irrecoverably lose their assets and may lose real money.615        /// 616        /// # Permissions617        /// 618        /// * Collection Owner.619        /// 620        /// # Arguments621        /// 622        /// * collection_id: collection to destroy.623        #[weight = <T as Config>::WeightInfo::destroy_collection()]624        pub fn destroy_collection(origin, collection_id: CollectionId) -> DispatchResult {625626            let sender = ensure_signed(origin)?;627            Self::check_owner_permissions(collection_id, sender)?;628629            <AddressTokens<T>>::remove_prefix(collection_id);630            <Allowances<T>>::remove_prefix(collection_id);631            <Balance<T>>::remove_prefix(collection_id);632            <ItemListIndex>::remove(collection_id);633            <AdminList<T>>::remove(collection_id);634            <Collection<T>>::remove(collection_id);635            <WhiteList<T>>::remove_prefix(collection_id);636637            <NftItemList<T>>::remove_prefix(collection_id);638            <FungibleItemList<T>>::remove_prefix(collection_id);639            <ReFungibleItemList<T>>::remove_prefix(collection_id);640641            <NftTransferBasket<T>>::remove_prefix(collection_id);642            <FungibleTransferBasket<T>>::remove_prefix(collection_id);643            <ReFungibleTransferBasket<T>>::remove_prefix(collection_id);644645            if CollectionCount::get() > 0646            {647                // bound couter648                let total = CollectionCount::get()649                    .checked_sub(1)650                    .ok_or(Error::<T>::NumOverflow)?;651652                CollectionCount::put(total);653            }654655            Ok(())656        }657658        /// Add an address to white list.659        /// 660        /// # Permissions661        /// 662        /// * Collection Owner663        /// * Collection Admin664        /// 665        /// # Arguments666        /// 667        /// * collection_id.668        /// 669        /// * address.670        #[weight = <T as Config>::WeightInfo::add_to_white_list()]671        pub fn add_to_white_list(origin, collection_id: CollectionId, address: T::AccountId) -> DispatchResult{672673            let sender = ensure_signed(origin)?;674            Self::check_owner_or_admin_permissions(collection_id, sender)?;675676            <WhiteList<T>>::insert(collection_id, address, true);677            678            Ok(())679        }680681        /// Remove an address from white list.682        /// 683        /// # Permissions684        /// 685        /// * Collection Owner686        /// * Collection Admin687        /// 688        /// # Arguments689        /// 690        /// * collection_id.691        /// 692        /// * address.693        #[weight = <T as Config>::WeightInfo::remove_from_white_list()]694        pub fn remove_from_white_list(origin, collection_id: CollectionId, address: T::AccountId) -> DispatchResult{695696            let sender = ensure_signed(origin)?;697            Self::check_owner_or_admin_permissions(collection_id, sender)?;698699            <WhiteList<T>>::remove(collection_id, address);700701            Ok(())702        }703704        /// Toggle between normal and white list access for the methods with access for `Anyone`.705        /// 706        /// # Permissions707        /// 708        /// * Collection Owner.709        /// 710        /// # Arguments711        /// 712        /// * collection_id.713        /// 714        /// * mode: [AccessMode]715        #[weight = <T as Config>::WeightInfo::set_public_access_mode()]716        pub fn set_public_access_mode(origin, collection_id: CollectionId, mode: AccessMode) -> DispatchResult717        {718            let sender = ensure_signed(origin)?;719720            Self::check_owner_permissions(collection_id, sender)?;721            let mut target_collection = <Collection<T>>::get(collection_id);722            target_collection.access = mode;723            <Collection<T>>::insert(collection_id, target_collection);724725            Ok(())726        }727728        /// Allows Anyone to create tokens if:729        /// * White List is enabled, and730        /// * Address is added to white list, and731        /// * This method was called with True parameter732        /// 733        /// # Permissions734        /// * Collection Owner735        ///736        /// # Arguments737        /// 738        /// * collection_id.739        /// 740        /// * mint_permission: Boolean parameter. If True, allows minting to Anyone with conditions above.741        #[weight = <T as Config>::WeightInfo::set_mint_permission()]742        pub fn set_mint_permission(origin, collection_id: CollectionId, mint_permission: bool) -> DispatchResult743        {744            let sender = ensure_signed(origin)?;745746            Self::check_owner_permissions(collection_id, sender)?;747            let mut target_collection = <Collection<T>>::get(collection_id);748            target_collection.mint_mode = mint_permission;749            <Collection<T>>::insert(collection_id, target_collection);750751            Ok(())752        }753754        /// Change the owner of the collection.755        /// 756        /// # Permissions757        /// 758        /// * Collection Owner.759        /// 760        /// # Arguments761        /// 762        /// * collection_id.763        /// 764        /// * new_owner.765        #[weight = <T as Config>::WeightInfo::change_collection_owner()]766        pub fn change_collection_owner(origin, collection_id: CollectionId, new_owner: T::AccountId) -> DispatchResult {767768            let sender = ensure_signed(origin)?;769            Self::check_owner_permissions(collection_id, sender)?;770            let mut target_collection = <Collection<T>>::get(collection_id);771            target_collection.owner = new_owner;772            <Collection<T>>::insert(collection_id, target_collection);773774            Ok(())775        }776777        /// Adds an admin of the Collection.778        /// 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. 779        /// 780        /// # Permissions781        /// 782        /// * Collection Owner.783        /// * Collection Admin.784        /// 785        /// # Arguments786        /// 787        /// * collection_id: ID of the Collection to add admin for.788        /// 789        /// * new_admin_id: Address of new admin to add.790        #[weight = <T as Config>::WeightInfo::add_collection_admin()]791        pub fn add_collection_admin(origin, collection_id: CollectionId, new_admin_id: T::AccountId) -> DispatchResult {792793            let sender = ensure_signed(origin)?;794            Self::check_owner_or_admin_permissions(collection_id, sender)?;795            let mut admin_arr: Vec<T::AccountId> = Vec::new();796797            if <AdminList<T>>::contains_key(collection_id)798            {799                admin_arr = <AdminList<T>>::get(collection_id);800                ensure!(!admin_arr.contains(&new_admin_id), Error::<T>::AlreadyAdmin);801            }802803            // Number of collection admins804            ensure!((admin_arr.len() as u64) < ChainLimit::get().collections_admins_limit, Error::<T>::CollectionAdminsLimitExceeded);805806            admin_arr.push(new_admin_id);807            <AdminList<T>>::insert(collection_id, admin_arr);808809            Ok(())810        }811812        /// 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.813        ///814        /// # Permissions815        /// 816        /// * Collection Owner.817        /// * Collection Admin.818        /// 819        /// # Arguments820        /// 821        /// * collection_id: ID of the Collection to remove admin for.822        /// 823        /// * account_id: Address of admin to remove.824        #[weight = <T as Config>::WeightInfo::remove_collection_admin()]825        pub fn remove_collection_admin(origin, collection_id: CollectionId, account_id: T::AccountId) -> DispatchResult {826827            let sender = ensure_signed(origin)?;828            Self::check_owner_or_admin_permissions(collection_id, sender)?;829            ensure!(<AdminList<T>>::contains_key(collection_id), Error::<T>::AdminNotFound);830831            let mut admin_arr = <AdminList<T>>::get(collection_id);832            admin_arr.retain(|i| *i != account_id);833            <AdminList<T>>::insert(collection_id, admin_arr);834835            Ok(())836        }837838        /// # Permissions839        /// 840        /// * Collection Owner841        /// 842        /// # Arguments843        /// 844        /// * collection_id.845        /// 846        /// * new_sponsor.847        #[weight = <T as Config>::WeightInfo::set_collection_sponsor()]848        pub fn set_collection_sponsor(origin, collection_id: CollectionId, new_sponsor: T::AccountId) -> DispatchResult {849850            let sender = ensure_signed(origin)?;851            ensure!(<Collection<T>>::contains_key(collection_id), Error::<T>::CollectionNotFound);852853            let mut target_collection = <Collection<T>>::get(collection_id);854            ensure!(sender == target_collection.owner, Error::<T>::NoPermission);855856            target_collection.sponsor = new_sponsor;857            target_collection.sponsor_confirmed = false;858            <Collection<T>>::insert(collection_id, target_collection);859860            Ok(())861        }862863        /// # Permissions864        /// 865        /// * Sponsor.866        /// 867        /// # Arguments868        /// 869        /// * collection_id.870        #[weight = <T as Config>::WeightInfo::confirm_sponsorship()]871        pub fn confirm_sponsorship(origin, collection_id: CollectionId) -> DispatchResult {872873            let sender = ensure_signed(origin)?;874            ensure!(<Collection<T>>::contains_key(collection_id), Error::<T>::CollectionNotFound);875876            let mut target_collection = <Collection<T>>::get(collection_id);877            ensure!(sender == target_collection.sponsor, Error::<T>::ConfirmUnsetSponsorFail);878879            target_collection.sponsor_confirmed = true;880            <Collection<T>>::insert(collection_id, target_collection);881882            Ok(())883        }884885        /// Switch back to pay-per-own-transaction model.886        ///887        /// # Permissions888        ///889        /// * Collection owner.890        /// 891        /// # Arguments892        /// 893        /// * collection_id.894        #[weight = <T as Config>::WeightInfo::remove_collection_sponsor()]895        pub fn remove_collection_sponsor(origin, collection_id: CollectionId) -> DispatchResult {896897            let sender = ensure_signed(origin)?;898            ensure!(<Collection<T>>::contains_key(collection_id), Error::<T>::CollectionNotFound);899900            let mut target_collection = <Collection<T>>::get(collection_id);901            ensure!(sender == target_collection.owner, Error::<T>::NoPermission);902903            target_collection.sponsor = T::AccountId::default();904            target_collection.sponsor_confirmed = false;905            <Collection<T>>::insert(collection_id, target_collection);906907            Ok(())908        }909910        /// This method creates a concrete instance of NFT Collection created with CreateCollection method.911        /// 912        /// # Permissions913        /// 914        /// * Collection Owner.915        /// * Collection Admin.916        /// * Anyone if917        ///     * White List is enabled, and918        ///     * Address is added to white list, and919        ///     * MintPermission is enabled (see SetMintPermission method)920        /// 921        /// # Arguments922        /// 923        /// * collection_id: ID of the collection.924        /// 925        /// * owner: Address, initial owner of the NFT.926        ///927        /// * data: Token data to store on chain.928        // #[weight =929        // (130_000_000 as Weight)930        // .saturating_add((2135 as Weight).saturating_mul((properties.len() as u64) as Weight))931        // .saturating_add(RocksDbWeight::get().reads(10 as Weight))932        // .saturating_add(RocksDbWeight::get().writes(8 as Weight))]933934        #[weight = <T as Config>::WeightInfo::create_item(data.len())]935        pub fn create_item(origin, collection_id: CollectionId, owner: T::AccountId, data: CreateItemData) -> DispatchResult {936937            let sender = ensure_signed(origin)?;938939            Self::collection_exists(collection_id)?;940941            let target_collection = <Collection<T>>::get(collection_id);942943            Self::can_create_items_in_collection(collection_id, &target_collection, &sender, &owner)?;944            Self::validate_create_item_args(&target_collection, &data)?;945            Self::create_item_no_validation(collection_id, owner, data)?;946947            Ok(())948        }949950        /// This method creates multiple instances of NFT Collection created with CreateCollection method.951        /// 952        /// # Permissions953        /// 954        /// * Collection Owner.955        /// * Collection Admin.956        /// * Anyone if957        ///     * White List is enabled, and958        ///     * Address is added to white list, and959        ///     * MintPermission is enabled (see SetMintPermission method)960        /// 961        /// # Arguments962        /// 963        /// * collection_id: ID of the collection.964        /// 965        /// * itemsData: Array items properties. Each property is an array of bytes itself, see [create_item].966        /// 967        /// * owner: Address, initial owner of the NFT.968        #[weight = <T as Config>::WeightInfo::create_item(items_data.into_iter()969                               .map(|data| { data.len() })970                               .sum())]971        pub fn create_multiple_items(origin, collection_id: CollectionId, owner: T::AccountId, items_data: Vec<CreateItemData>) -> DispatchResult {972973            ensure!(items_data.len() > 0, Error::<T>::EmptyArgument);974            let sender = ensure_signed(origin)?;975976            Self::collection_exists(collection_id)?;977            let target_collection = <Collection<T>>::get(collection_id);978979            Self::can_create_items_in_collection(collection_id, &target_collection, &sender, &owner)?;980981            for data in &items_data {982                Self::validate_create_item_args(&target_collection, data)?;983            }984            for data in &items_data {985                Self::create_item_no_validation(collection_id, owner.clone(), data.clone())?;986            }987988            Ok(())989        }990991        /// Destroys a concrete instance of NFT.992        /// 993        /// # Permissions994        /// 995        /// * Collection Owner.996        /// * Collection Admin.997        /// * Current NFT Owner.998        /// 999        /// # Arguments1000        /// 1001        /// * collection_id: ID of the collection.1002        /// 1003        /// * item_id: ID of NFT to burn.1004        #[weight = <T as Config>::WeightInfo::burn_item()]1005        pub fn burn_item(origin, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {10061007            let sender = ensure_signed(origin)?;1008            Self::collection_exists(collection_id)?;10091010            // Transfer permissions check1011            let target_collection = <Collection<T>>::get(collection_id);1012            ensure!(Self::is_item_owner(sender.clone(), collection_id, item_id) ||1013                Self::is_owner_or_admin_permissions(collection_id, sender.clone()),1014                Error::<T>::NoPermission);10151016            if target_collection.access == AccessMode::WhiteList {1017                Self::check_white_list(collection_id, &sender)?;1018            }10191020            match target_collection.mode1021            {1022                CollectionMode::NFT => Self::burn_nft_item(collection_id, item_id)?,1023                CollectionMode::Fungible(_)  => Self::burn_fungible_item(&sender, collection_id, value)?,1024                CollectionMode::ReFungible  => Self::burn_refungible_item(collection_id, item_id, &sender)?,1025                _ => ()1026            };10271028            // call event1029            Self::deposit_event(RawEvent::ItemDestroyed(collection_id, item_id));10301031            Ok(())1032        }10331034        /// Change ownership of the token.1035        /// 1036        /// # Permissions1037        /// 1038        /// * Collection Owner1039        /// * Collection Admin1040        /// * Current NFT owner1041        ///1042        /// # Arguments1043        /// 1044        /// * recipient: Address of token recipient.1045        /// 1046        /// * collection_id.1047        /// 1048        /// * item_id: ID of the item1049        ///     * Non-Fungible Mode: Required.1050        ///     * Fungible Mode: Ignored.1051        ///     * Re-Fungible Mode: Required.1052        /// 1053        /// * value: Amount to transfer.1054        ///     * Non-Fungible Mode: Ignored1055        ///     * Fungible Mode: Must specify transferred amount1056        ///     * Re-Fungible Mode: Must specify transferred portion (between 0 and 1)1057        #[weight = <T as Config>::WeightInfo::transfer()]1058        pub fn transfer(origin, recipient: T::AccountId, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {1059            let sender = ensure_signed(origin)?;1060            Self::transfer_internal(sender, recipient, collection_id, item_id, value)1061        }10621063        /// Set, change, or remove approved address to transfer the ownership of the NFT.1064        /// 1065        /// # Permissions1066        /// 1067        /// * Collection Owner1068        /// * Collection Admin1069        /// * Current NFT owner1070        /// 1071        /// # Arguments1072        /// 1073        /// * approved: Address that is approved to transfer this NFT or zero (if needed to remove approval).1074        /// 1075        /// * collection_id.1076        /// 1077        /// * item_id: ID of the item.1078        #[weight = <T as Config>::WeightInfo::approve()]1079        pub fn approve(origin, spender: T::AccountId, collection_id: CollectionId, item_id: TokenId, amount: u128) -> DispatchResult {10801081            let sender = ensure_signed(origin)?;10821083            Self::collection_exists(collection_id)?;1084            Self::token_exists(collection_id, item_id, &sender)?;10851086            // Transfer permissions check1087            let target_collection = <Collection<T>>::get(collection_id);1088            ensure!(Self::is_item_owner(sender.clone(), collection_id, item_id) ||1089                Self::is_owner_or_admin_permissions(collection_id, sender.clone()),1090                Error::<T>::NoPermission);10911092            if target_collection.access == AccessMode::WhiteList {1093                Self::check_white_list(collection_id, &sender)?;1094                Self::check_white_list(collection_id, &spender)?;1095            }10961097            let allowance_exists = <Allowances<T>>::contains_key(collection_id, (item_id, &sender, &spender));1098            let mut allowance: u128 = amount;1099            if allowance_exists {1100                allowance += <Allowances<T>>::get(collection_id, (item_id, &sender, &spender));1101            }1102            <Allowances<T>>::insert(collection_id, (item_id, sender.clone(), spender.clone()), allowance);11031104            Ok(())1105        }1106        1107        /// 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.1108        /// 1109        /// # Permissions1110        /// * Collection Owner1111        /// * Collection Admin1112        /// * Current NFT owner1113        /// * Address approved by current NFT owner1114        /// 1115        /// # Arguments1116        /// 1117        /// * from: Address that owns token.1118        /// 1119        /// * recipient: Address of token recipient.1120        /// 1121        /// * collection_id.1122        /// 1123        /// * item_id: ID of the item.1124        /// 1125        /// * value: Amount to transfer.1126        #[weight = <T as Config>::WeightInfo::transfer_from()]1127        pub fn transfer_from(origin, from: T::AccountId, recipient: T::AccountId, collection_id: CollectionId, item_id: TokenId, value: u128 ) -> DispatchResult {11281129            let sender = ensure_signed(origin)?;1130            let mut appoved_transfer = false;11311132            // Check approval1133            let mut approval: u128 = 0;1134            if <Allowances<T>>::contains_key(collection_id, (item_id, &from, &sender)) {1135                approval = <Allowances<T>>::get(collection_id, (item_id, &from, &sender));1136                ensure!(approval >= value, Error::<T>::TokenValueNotEnough);1137                appoved_transfer = true;1138            }11391140            let target_collection = <Collection<T>>::get(collection_id);11411142            // Limits check1143            Self::is_correct_transfer(collection_id, &target_collection, &recipient)?;11441145            // Transfer permissions check         1146            ensure!(appoved_transfer || Self::is_owner_or_admin_permissions(collection_id, sender.clone()),1147                Error::<T>::NoPermission);11481149            if target_collection.access == AccessMode::WhiteList {1150                Self::check_white_list(collection_id, &sender)?;1151                Self::check_white_list(collection_id, &recipient)?;1152            }11531154            // Reduce approval by transferred amount or remove if remaining approval drops to 01155            if approval.checked_sub(value).unwrap_or(0) > 0 {1156                <Allowances<T>>::insert(collection_id, (item_id, &from, &sender), approval - value);1157            }1158            else {1159                <Allowances<T>>::remove(collection_id, (item_id, &from, &sender));1160            }11611162            match target_collection.mode1163            {1164                CollectionMode::NFT => Self::transfer_nft(collection_id, item_id, from, recipient)?,1165                CollectionMode::Fungible(_)  => Self::transfer_fungible(collection_id, value, &from, &recipient)?,1166                CollectionMode::ReFungible  => Self::transfer_refungible(collection_id, item_id, value, from.clone(), recipient)?,1167                _ => ()1168            };11691170            Ok(())1171        }11721173        // #[weight = 0]1174        // pub fn safe_transfer_from(origin, collection_id: CollectionId, item_id: TokenId, new_owner: T::AccountId) -> DispatchResult {11751176        //     // let no_perm_mes = "You do not have permissions to modify this collection";1177        //     // ensure!(<ApprovedList<T>>::contains_key((collection_id, item_id)), no_perm_mes);1178        //     // let list_itm = <ApprovedList<T>>::get((collection_id, item_id));1179        //     // ensure!(list_itm.contains(&new_owner.clone()), no_perm_mes);11801181        //     // // on_nft_received  call11821183        //     // Self::transfer(origin, collection_id, item_id, new_owner)?;11841185        //     Ok(())1186        // }11871188        /// Set off-chain data schema.1189        /// 1190        /// # Permissions1191        /// 1192        /// * Collection Owner1193        /// * Collection Admin1194        /// 1195        /// # Arguments1196        /// 1197        /// * collection_id.1198        /// 1199        /// * schema: String representing the offchain data schema.1200        #[weight = <T as Config>::WeightInfo::set_variable_meta_data()]1201        pub fn set_variable_meta_data (1202            origin,1203            collection_id: CollectionId,1204            item_id: TokenId,1205            data: Vec<u8>1206        ) -> DispatchResult {1207            let sender = ensure_signed(origin)?;1208            1209            Self::collection_exists(collection_id)?;1210            Self::token_exists(collection_id, item_id, &sender)?;12111212            ensure!(ChainLimit::get().custom_data_limit >= data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);12131214            // Modify permissions check1215            let target_collection = <Collection<T>>::get(collection_id);1216            ensure!(Self::is_item_owner(sender.clone(), collection_id, item_id) ||1217                Self::is_owner_or_admin_permissions(collection_id, sender.clone()),1218                Error::<T>::NoPermission);12191220            match target_collection.mode1221            {1222                CollectionMode::NFT => Self::set_nft_variable_data(collection_id, item_id, data)?,1223                CollectionMode::ReFungible  => Self::set_re_fungible_variable_data(collection_id, item_id, data)?,1224                CollectionMode::Fungible(_) => fail!(Error::<T>::CantStoreMetadataInFungibleTokens),1225                _ => fail!(Error::<T>::UnexpectedCollectionType)1226            };12271228            Ok(())1229        }1230 1231        /// Set schema standard1232        /// ImageURL1233        /// Unique1234        /// 1235        /// # Permissions1236        /// 1237        /// * Collection Owner1238        /// * Collection Admin1239        /// 1240        /// # Arguments1241        /// 1242        /// * collection_id.1243        /// 1244        /// * schema: SchemaVersion: enum1245        #[weight = <T as Config>::WeightInfo::set_schema_version()]1246        pub fn set_schema_version(1247            origin,1248            collection_id: CollectionId,1249            version: SchemaVersion1250        ) -> DispatchResult {1251            let sender = ensure_signed(origin)?;1252            Self::check_owner_or_admin_permissions(collection_id, sender.clone())?;1253            let mut target_collection = <Collection<T>>::get(collection_id);1254            target_collection.schema_version = version;1255            <Collection<T>>::insert(collection_id, target_collection);12561257            Ok(())1258        }12591260        /// Set off-chain data schema.1261        /// 1262        /// # Permissions1263        /// 1264        /// * Collection Owner1265        /// * Collection Admin1266        /// 1267        /// # Arguments1268        /// 1269        /// * collection_id.1270        /// 1271        /// * schema: String representing the offchain data schema.1272        #[weight = <T as Config>::WeightInfo::set_offchain_schema()]1273        pub fn set_offchain_schema(1274            origin,1275            collection_id: CollectionId,1276            schema: Vec<u8>1277        ) -> DispatchResult {1278            let sender = ensure_signed(origin)?;1279            Self::check_owner_or_admin_permissions(collection_id, sender.clone())?;12801281            // check schema limit1282            ensure!(schema.len() as u32 <= ChainLimit::get().offchain_schema_limit, "");12831284            let mut target_collection = <Collection<T>>::get(collection_id);1285            target_collection.offchain_schema = schema;1286            <Collection<T>>::insert(collection_id, target_collection);12871288            Ok(())1289        }12901291        /// Set const on-chain data schema.1292        /// 1293        /// # Permissions1294        /// 1295        /// * Collection Owner1296        /// * Collection Admin1297        /// 1298        /// # Arguments1299        /// 1300        /// * collection_id.1301        /// 1302        /// * schema: String representing the const on-chain data schema.1303        #[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1304        pub fn set_const_on_chain_schema (1305            origin,1306            collection_id: CollectionId,1307            schema: Vec<u8>1308        ) -> DispatchResult {1309            let sender = ensure_signed(origin)?;1310            Self::check_owner_or_admin_permissions(collection_id, sender.clone())?;13111312            // check schema limit1313            ensure!(schema.len() as u32 <= ChainLimit::get().const_on_chain_schema_limit, "");13141315            let mut target_collection = <Collection<T>>::get(collection_id);1316            target_collection.const_on_chain_schema = schema;1317            <Collection<T>>::insert(collection_id, target_collection);13181319            Ok(())1320        }13211322        /// Set variable on-chain data schema.1323        /// 1324        /// # Permissions1325        /// 1326        /// * Collection Owner1327        /// * Collection Admin1328        /// 1329        /// # Arguments1330        /// 1331        /// * collection_id.1332        /// 1333        /// * schema: String representing the variable on-chain data schema.1334        #[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1335        pub fn set_variable_on_chain_schema (1336            origin,1337            collection_id: CollectionId,1338            schema: Vec<u8>1339        ) -> DispatchResult {1340            let sender = ensure_signed(origin)?;1341            Self::check_owner_or_admin_permissions(collection_id, sender.clone())?;13421343            // check schema limit1344            ensure!(schema.len() as u32 <= ChainLimit::get().variable_on_chain_schema_limit, "");13451346            let mut target_collection = <Collection<T>>::get(collection_id);1347            target_collection.variable_on_chain_schema = schema;1348            <Collection<T>>::insert(collection_id, target_collection);13491350            Ok(())1351        }13521353        // Sudo permissions function1354        #[weight = <T as Config>::WeightInfo::set_chain_limits()]1355        pub fn set_chain_limits(1356            origin,1357            limits: ChainLimits1358        ) -> DispatchResult {13591360            #[cfg(not(feature = "runtime-benchmarks"))]1361            ensure_root(origin)?;13621363            <ChainLimit>::put(limits);1364            Ok(())1365        }13661367        /// Enable smart contract self-sponsoring.1368        /// 1369        /// # Permissions1370        /// 1371        /// * Contract Owner1372        /// 1373        /// # Arguments1374        /// 1375        /// * contract address1376        /// * enable flag1377        /// 1378        #[weight = <T as Config>::WeightInfo::enable_contract_sponsoring()]1379        pub fn enable_contract_sponsoring(1380            origin,1381            contract_address: T::AccountId,1382            enable: bool1383        ) -> DispatchResult {13841385            let sender = ensure_signed(origin)?;13861387            #[cfg(feature = "runtime-benchmarks")]1388            <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());13891390            Self::ensure_contract_owned(sender, &contract_address)?;13911392            <ContractSelfSponsoring<T>>::insert(contract_address, enable);1393            Ok(())1394        }13951396        /// Set the rate limit for contract sponsoring to specified number of blocks.1397        /// 1398        /// If not set (has the default value of 0 blocks), the sponsoring will be disabled. 1399        /// If set to the number B (for blocks), the transactions will be sponsored with a rate 1400        /// limit of B, i.e. fees for every transaction sent to this smart contract will be paid 1401        /// from contract endowment if there are at least B blocks between such transactions. 1402        /// Nonetheless, if transactions are sent more frequently, the fees are paid by the sender.1403        /// 1404        /// # Permissions1405        /// 1406        /// * Contract Owner1407        /// 1408        /// # Arguments1409        /// 1410        /// -`contract_address`: Address of the contract to sponsor1411        /// -`rate_limit`: Number of blocks to wait until the next sponsored transaction is allowed1412        /// 1413        #[weight = <T as Config>::WeightInfo::set_contract_sponsoring_rate_limit()]1414        pub fn set_contract_sponsoring_rate_limit(1415            origin,1416            contract_address: T::AccountId,1417            rate_limit: T::BlockNumber1418        ) -> DispatchResult {1419            let sender = ensure_signed(origin)?;14201421            #[cfg(feature = "runtime-benchmarks")]1422            <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());14231424            Self::ensure_contract_owned(sender, &contract_address)?;1425            <ContractSponsoringRateLimit<T>>::insert(contract_address, rate_limit);1426            Ok(())1427        }14281429        /// Enable the white list for a contract. Only addresses added to the white list with addToContractWhiteList will be able to call this smart contract.1430        /// 1431        /// # Permissions1432        /// 1433        /// * Address that deployed smart contract.1434        /// 1435        /// # Arguments1436        /// 1437        /// -`contract_address`: Address of the contract.1438        /// 1439        /// - `enable`: .  1440        #[weight = <T as Config>::WeightInfo::toggle_contract_white_list()]1441        pub fn toggle_contract_white_list(1442            origin,1443            contract_address: T::AccountId,1444            enable: bool1445        ) -> DispatchResult {1446            let sender = ensure_signed(origin)?;14471448            #[cfg(feature = "runtime-benchmarks")]1449            <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());14501451            Self::ensure_contract_owned(sender, &contract_address)?;1452            <ContractWhiteListEnabled<T>>::insert(contract_address, enable);1453            Ok(())1454        }1455        1456        /// Add an address to smart contract white list.1457        /// 1458        /// # Permissions1459        /// 1460        /// * Address that deployed smart contract.1461        /// 1462        /// # Arguments1463        /// 1464        /// -`contract_address`: Address of the contract.1465        ///1466        /// -`account_address`: Address to add.1467        #[weight = <T as Config>::WeightInfo::add_to_contract_white_list()]1468        pub fn add_to_contract_white_list(1469            origin,1470            contract_address: T::AccountId,1471            account_address: T::AccountId1472        ) -> DispatchResult {1473            let sender = ensure_signed(origin)?;14741475            #[cfg(feature = "runtime-benchmarks")]1476            <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());1477            1478            Self::ensure_contract_owned(sender, &contract_address)?;      1479            <ContractWhiteList<T>>::insert(contract_address, account_address, true);1480            Ok(())1481        }14821483        /// Remove an address from smart contract white list.1484        /// 1485        /// # Permissions1486        /// 1487        /// * Address that deployed smart contract.1488        /// 1489        /// # Arguments1490        /// 1491        /// -`contract_address`: Address of the contract.1492        ///1493        /// -`account_address`: Address to remove.1494        #[weight = <T as Config>::WeightInfo::remove_from_contract_white_list()]1495        pub fn remove_from_contract_white_list(1496            origin,1497            contract_address: T::AccountId,1498            account_address: T::AccountId1499        ) -> DispatchResult {1500            let sender = ensure_signed(origin)?;15011502            #[cfg(feature = "runtime-benchmarks")]1503            <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());15041505            Self::ensure_contract_owned(sender, &contract_address)?;1506            <ContractWhiteList<T>>::remove(contract_address, account_address);1507            Ok(())1508        }15091510        #[weight = <T as Config>::WeightInfo::set_collection_limits()]1511        pub fn set_collection_limits(1512            origin,1513            collection_id: u32,1514            limits: CollectionLimits,1515        ) -> DispatchResult {1516            let sender = ensure_signed(origin)?;1517            Self::check_owner_permissions(collection_id, sender.clone())?;1518            let mut target_collection = <Collection<T>>::get(collection_id);1519            let chain_limits = ChainLimit::get();1520            let climits = target_collection.limits;15211522            // collection bounds1523            ensure!(limits.sponsor_transfer_timeout <= MAX_SPONSOR_TIMEOUT &&1524                limits.account_token_ownership_limit <= MAX_TOKEN_OWNERSHIP,  1525                Error::<T>::CollectionLimitBoundsExceeded);15261527            // token_limit   check  prev1528            ensure!(climits.token_limit > limits.token_limit && 1529                limits.token_limit <= chain_limits.account_token_ownership_limit, 1530                Error::<T>::AccountTokenLimitExceeded);15311532            target_collection.limits = limits;1533            <Collection<T>>::insert(collection_id, target_collection);15341535            Ok(())1536        } 1537    }1538}15391540impl<T: Config> Module<T> {15411542    pub fn transfer_internal(sender: T::AccountId, recipient: T::AccountId, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {15431544        let target_collection = <Collection<T>>::get(collection_id);15451546        // Limits check1547        Self::is_correct_transfer(collection_id, &target_collection, &recipient)?;15481549        // Transfer permissions check1550        ensure!(Self::is_item_owner(sender.clone(), collection_id, item_id) ||1551            Self::is_owner_or_admin_permissions(collection_id, sender.clone()),1552            Error::<T>::NoPermission);15531554        if target_collection.access == AccessMode::WhiteList {1555            Self::check_white_list(collection_id, &sender)?;1556            Self::check_white_list(collection_id, &recipient)?;1557        }15581559        match target_collection.mode1560        {1561            CollectionMode::NFT => Self::transfer_nft(collection_id, item_id, sender.clone(), recipient)?,1562            CollectionMode::Fungible(_)  => Self::transfer_fungible(collection_id, value, &sender, &recipient)?,1563            CollectionMode::ReFungible  => Self::transfer_refungible(collection_id, item_id, value, sender.clone(), recipient)?,1564            _ => ()1565        };15661567        Ok(())1568    }156915701571    fn is_correct_transfer(collection_id: CollectionId, collection: &CollectionType<T::AccountId>, recipient: &T::AccountId) -> DispatchResult {15721573        // check token limit and account token limit1574        let account_items: u32 = <AddressTokens<T>>::get(collection_id, recipient).len() as u32;1575        ensure!(collection.limits.account_token_ownership_limit > account_items,  Error::<T>::AccountTokenLimitExceeded);1576        1577        Ok(())1578    }15791580    fn can_create_items_in_collection(collection_id: CollectionId, collection: &CollectionType<T::AccountId>, sender: &T::AccountId, owner: &T::AccountId) -> DispatchResult {15811582        // check token limit and account token limit1583        let total_items: u32 = ItemListIndex::get(collection_id);1584        let account_items: u32 = <AddressTokens<T>>::get(collection_id, owner).len() as u32;1585        ensure!(collection.limits.token_limit > total_items,  Error::<T>::CollectionTokenLimitExceeded);1586        ensure!(collection.limits.account_token_ownership_limit > account_items,  Error::<T>::AccountTokenLimitExceeded);15871588        if !Self::is_owner_or_admin_permissions(collection_id, sender.clone()) {1589            ensure!(collection.mint_mode == true, Error::<T>::PublicMintingNotAllowed);1590            Self::check_white_list(collection_id, owner)?;1591            Self::check_white_list(collection_id, sender)?;1592        }15931594        Ok(())1595    }15961597    fn validate_create_item_args(target_collection: &CollectionType<T::AccountId>, data: &CreateItemData) -> DispatchResult {1598        match target_collection.mode1599        {1600            CollectionMode::NFT => {1601                if let CreateItemData::NFT(data) = data {1602                    // check sizes1603                    ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, Error::<T>::TokenConstDataLimitExceeded);1604                    ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);1605                } else {1606                    fail!(Error::<T>::NotNftDataUsedToMintNftCollectionToken);1607                }1608            },1609            CollectionMode::Fungible(_) => {1610                if let CreateItemData::Fungible(_) = data {1611                } else {1612                    fail!(Error::<T>::NotFungibleDataUsedToMintFungibleCollectionToken);1613                }1614            },1615            CollectionMode::ReFungible => {1616                if let CreateItemData::ReFungible(data) = data {16171618                    // check sizes1619                    ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, Error::<T>::TokenConstDataLimitExceeded);1620                    ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);16211622                    // Check refungibility limits1623                    ensure!(data.pieces <= MAX_REFUNGIBLE_PIECES, Error::<T>::WrongRefungiblePieces);1624                    ensure!(data.pieces > 0, Error::<T>::WrongRefungiblePieces);1625                } else {1626                    fail!(Error::<T>::NotReFungibleDataUsedToMintReFungibleCollectionToken);1627                }1628            },1629            _ => { fail!(Error::<T>::UnexpectedCollectionType); }1630        };16311632        Ok(())1633    }16341635    fn create_item_no_validation(collection_id: CollectionId, owner: T::AccountId, data: CreateItemData) -> DispatchResult {1636        match data1637        {1638            CreateItemData::NFT(data) => {1639                let item = NftItemType {1640                    owner: owner.clone(),1641                    const_data: data.const_data,1642                    variable_data: data.variable_data1643                };16441645                Self::add_nft_item(collection_id, item)?;1646            },1647            CreateItemData::Fungible(data) => {1648                Self::add_fungible_item(collection_id, &owner, data.value)?;1649            },1650            CreateItemData::ReFungible(data) => {1651                let mut owner_list = Vec::new();1652                owner_list.push(Ownership {owner: owner.clone(), fraction: data.pieces});16531654                let item = ReFungibleItemType {1655                    owner: owner_list,1656                    const_data: data.const_data,1657                    variable_data: data.variable_data1658                };16591660                Self::add_refungible_item(collection_id, item)?;1661            }1662        };16631664        // call event1665        Self::deposit_event(RawEvent::ItemCreated(collection_id, <ItemListIndex>::get(collection_id), owner));16661667        Ok(())1668    }16691670    fn add_fungible_item(collection_id: CollectionId, owner: &T::AccountId, value: u128) -> DispatchResult {16711672        // Does new owner already have an account?1673        let mut balance: u128 = 0;1674        if <FungibleItemList<T>>::contains_key(collection_id, owner) {1675            balance = <FungibleItemList<T>>::get(collection_id, owner).value;1676        } 16771678        // Mint 1679        let item = FungibleItemType {1680            value: balance + value1681        };1682        <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), item);16831684        // Update balance1685        let new_balance = <Balance<T>>::get(collection_id, owner)1686            .checked_add(value)1687            .ok_or(Error::<T>::NumOverflow)?;1688        <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);16891690        Ok(())1691    }16921693    fn add_refungible_item(collection_id: CollectionId, item: ReFungibleItemType<T::AccountId>) -> DispatchResult {1694        let current_index = <ItemListIndex>::get(collection_id)1695            .checked_add(1)1696            .ok_or(Error::<T>::NumOverflow)?;1697        let itemcopy = item.clone();16981699        let value = item.owner.first().unwrap().fraction;1700        let owner = item.owner.first().unwrap().owner.clone();17011702        Self::add_token_index(collection_id, current_index, &owner)?;17031704        <ItemListIndex>::insert(collection_id, current_index);1705        <ReFungibleItemList<T>>::insert(collection_id, current_index, itemcopy);17061707        // Update balance1708        let new_balance = <Balance<T>>::get(collection_id, &owner)1709            .checked_add(value)1710            .ok_or(Error::<T>::NumOverflow)?;1711        <Balance<T>>::insert(collection_id, owner.clone(), new_balance);17121713        Ok(())1714    }17151716    fn add_nft_item(collection_id: CollectionId, item: NftItemType<T::AccountId>) -> DispatchResult {1717        let current_index = <ItemListIndex>::get(collection_id)1718            .checked_add(1)1719            .ok_or(Error::<T>::NumOverflow)?;17201721        let item_owner = item.owner.clone();1722        Self::add_token_index(collection_id, current_index, &item.owner)?;17231724        <ItemListIndex>::insert(collection_id, current_index);1725        <NftItemList<T>>::insert(collection_id, current_index, item);17261727        // Update balance1728        let new_balance = <Balance<T>>::get(collection_id, item_owner.clone())1729            .checked_add(1)1730            .ok_or(Error::<T>::NumOverflow)?;1731        <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);17321733        Ok(())1734    }17351736    fn burn_refungible_item(1737        collection_id: CollectionId,1738        item_id: TokenId,1739        owner: &T::AccountId,1740    ) -> DispatchResult {1741        ensure!(1742            <ReFungibleItemList<T>>::contains_key(collection_id, item_id),1743            Error::<T>::TokenNotFound1744        );1745        let mut token = <ReFungibleItemList<T>>::get(collection_id, item_id);1746        let rft_balance = token1747            .owner1748            .iter()1749            .filter(|&i| i.owner == *owner)1750            .next()1751            .unwrap();1752        Self::remove_token_index(collection_id, item_id, owner)?;17531754        // update balance1755        let new_balance = <Balance<T>>::get(collection_id, rft_balance.owner.clone())1756            .checked_sub(rft_balance.fraction)1757            .ok_or(Error::<T>::NumOverflow)?;1758        <Balance<T>>::insert(collection_id, rft_balance.owner.clone(), new_balance);17591760        // Re-create owners list with sender removed1761        let index = token1762            .owner1763            .iter()1764            .position(|i| i.owner == *owner)1765            .unwrap();1766        token.owner.remove(index);1767        let owner_count = token.owner.len();17681769        // Burn the token completely if this was the last (only) owner1770        if owner_count == 0 {1771            <ReFungibleItemList<T>>::remove(collection_id, item_id);1772        }1773        else {1774            <ReFungibleItemList<T>>::insert(collection_id, item_id, token);1775        }17761777        Ok(())1778    }17791780    fn burn_nft_item(collection_id: CollectionId, item_id: TokenId) -> DispatchResult {1781        ensure!(1782            <NftItemList<T>>::contains_key(collection_id, item_id),1783            Error::<T>::TokenNotFound1784        );1785        let item = <NftItemList<T>>::get(collection_id, item_id);1786        Self::remove_token_index(collection_id, item_id, &item.owner)?;17871788        // update balance1789        let new_balance = <Balance<T>>::get(collection_id, &item.owner)1790            .checked_sub(1)1791            .ok_or(Error::<T>::NumOverflow)?;1792        <Balance<T>>::insert(collection_id, item.owner.clone(), new_balance);1793        <NftItemList<T>>::remove(collection_id, item_id);17941795        Ok(())1796    }17971798    fn burn_fungible_item(owner: &T::AccountId, collection_id: CollectionId, value: u128) -> DispatchResult {1799        ensure!(1800            <FungibleItemList<T>>::contains_key(collection_id, owner),1801            Error::<T>::TokenNotFound1802        );1803        let mut balance = <FungibleItemList<T>>::get(collection_id, owner);1804        ensure!(balance.value >= value, Error::<T>::TokenValueNotEnough);18051806        // update balance1807        let new_balance = <Balance<T>>::get(collection_id, owner)1808            .checked_sub(value)1809            .ok_or(Error::<T>::NumOverflow)?;1810        <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);18111812        if balance.value - value > 0 {1813            balance.value -= value;1814            <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), balance);1815        }1816        else {1817            <FungibleItemList<T>>::remove(collection_id, owner);1818        }18191820        Ok(())1821    }18221823    fn collection_exists(collection_id: CollectionId) -> DispatchResult {1824        ensure!(1825            <Collection<T>>::contains_key(collection_id),1826            Error::<T>::CollectionNotFound1827        );1828        Ok(())1829    }18301831    fn check_owner_permissions(collection_id: CollectionId, subject: T::AccountId) -> DispatchResult {1832        Self::collection_exists(collection_id)?;18331834        let target_collection = <Collection<T>>::get(collection_id);1835        ensure!(1836            subject == target_collection.owner,1837            Error::<T>::NoPermission1838        );18391840        Ok(())1841    }18421843    fn is_owner_or_admin_permissions(collection_id: CollectionId, subject: T::AccountId) -> bool {1844        let target_collection = <Collection<T>>::get(collection_id);1845        let mut result: bool = subject == target_collection.owner;1846        let exists = <AdminList<T>>::contains_key(collection_id);18471848        if !result & exists {1849            if <AdminList<T>>::get(collection_id).contains(&subject) {1850                result = true1851            }1852        }18531854        result1855    }18561857    fn check_owner_or_admin_permissions(1858        collection_id: CollectionId,1859        subject: T::AccountId,1860    ) -> DispatchResult {1861        Self::collection_exists(collection_id)?;1862        let result = Self::is_owner_or_admin_permissions(collection_id, subject.clone());18631864        ensure!(1865            result,1866            Error::<T>::NoPermission1867        );1868        Ok(())1869    }18701871    fn is_item_owner(subject: T::AccountId, collection_id: CollectionId, item_id: TokenId) -> bool {1872        let target_collection = <Collection<T>>::get(collection_id);18731874        match target_collection.mode {1875            CollectionMode::NFT => {1876                <NftItemList<T>>::get(collection_id, item_id).owner == subject1877            }1878            CollectionMode::Fungible(_) => {1879                <FungibleItemList<T>>::contains_key(collection_id, &subject)1880            }1881            CollectionMode::ReFungible => {1882                <ReFungibleItemList<T>>::get(collection_id, item_id)1883                    .owner1884                    .iter()1885                    .any(|i| i.owner == subject)1886            }1887            CollectionMode::Invalid => false,1888        }1889    }18901891    fn check_white_list(collection_id: CollectionId, address: &T::AccountId) -> DispatchResult {1892        let mes = Error::<T>::AddresNotInWhiteList;1893        ensure!(<WhiteList<T>>::contains_key(collection_id, address), mes);18941895        Ok(())1896    }18971898    /// Check if token exists. In case of Fungible, check if there is an entry for 1899    /// the owner in fungible balances double map1900    fn token_exists(1901        collection_id: CollectionId,1902        item_id: TokenId,1903        owner: &T::AccountId1904    ) -> DispatchResult {1905        let target_collection = <Collection<T>>::get(collection_id);1906        let exists = match target_collection.mode1907        {1908            CollectionMode::NFT => <NftItemList<T>>::contains_key(collection_id, item_id),1909            CollectionMode::Fungible(_)  => <FungibleItemList<T>>::contains_key(collection_id, owner),1910            CollectionMode::ReFungible  => <ReFungibleItemList<T>>::contains_key(collection_id, item_id),1911            _ => false1912        };19131914        ensure!(exists == true, Error::<T>::TokenNotFound);1915        Ok(())1916    }19171918    fn transfer_fungible(1919        collection_id: CollectionId,1920        value: u128,1921        owner: &T::AccountId,1922        recipient: &T::AccountId,1923    ) -> DispatchResult {1924        Self::token_exists(collection_id, 0, owner)?;19251926        let mut balance = <FungibleItemList<T>>::get(collection_id, owner);1927        ensure!(balance.value >= value, Error::<T>::TokenValueTooLow);19281929        // Send balance to recipient (updates balanceOf of recipient)1930        Self::add_fungible_item(collection_id, recipient, value)?;19311932        // update balanceOf of sender1933        <Balance<T>>::insert(collection_id, (*owner).clone(), balance.value - value);19341935        // Reduce or remove sender1936        if balance.value == value {1937            <FungibleItemList<T>>::remove(collection_id, owner);1938        }1939        else {1940            balance.value -= value;1941            <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), balance);1942        }19431944        Ok(())1945    }19461947    fn transfer_refungible(1948        collection_id: CollectionId,1949        item_id: TokenId,1950        value: u128,1951        owner: T::AccountId,1952        new_owner: T::AccountId,1953    ) -> DispatchResult {1954        Self::token_exists(collection_id, item_id, &owner)?;19551956        let full_item = <ReFungibleItemList<T>>::get(collection_id, item_id);1957        let item = full_item1958            .owner1959            .iter()1960            .filter(|i| i.owner == owner)1961            .next()1962            .ok_or(Error::<T>::NumOverflow)?;1963        let amount = item.fraction;19641965        ensure!(amount >= value, Error::<T>::TokenValueTooLow);19661967        // update balance1968        let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())1969            .checked_sub(value)1970            .ok_or(Error::<T>::NumOverflow)?;1971        <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);19721973        let balancenew_owner = <Balance<T>>::get(collection_id, new_owner.clone())1974            .checked_add(value)1975            .ok_or(Error::<T>::NumOverflow)?;1976        <Balance<T>>::insert(collection_id, new_owner.clone(), balancenew_owner);19771978        let old_owner = item.owner.clone();1979        let new_owner_has_account = full_item.owner.iter().any(|i| i.owner == new_owner);19801981        // transfer1982        if amount == value && !new_owner_has_account {1983            // change owner1984            // new owner do not have account1985            let mut new_full_item = full_item.clone();1986            new_full_item1987                .owner1988                .iter_mut()1989                .find(|i| i.owner == owner)1990                .unwrap()1991                .owner = new_owner.clone();1992            <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);19931994            // update index collection1995            Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;1996        } else {1997            let mut new_full_item = full_item.clone();1998            new_full_item1999                .owner2000                .iter_mut()2001                .find(|i| i.owner == owner)2002                .unwrap()2003                .fraction -= value;20042005            // separate amount2006            if new_owner_has_account {2007                // new owner has account2008                new_full_item2009                    .owner2010                    .iter_mut()2011                    .find(|i| i.owner == new_owner)2012                    .unwrap()2013                    .fraction += value;2014            } else {2015                // new owner do not have account2016                new_full_item.owner.push(Ownership {2017                    owner: new_owner.clone(),2018                    fraction: value,2019                });2020                Self::add_token_index(collection_id, item_id, &new_owner)?;2021            }20222023            <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);2024        }20252026        Ok(())2027    }20282029    fn transfer_nft(2030        collection_id: CollectionId,2031        item_id: TokenId,2032        sender: T::AccountId,2033        new_owner: T::AccountId,2034    ) -> DispatchResult {2035        Self::token_exists(collection_id, item_id, &sender)?;20362037        let mut item = <NftItemList<T>>::get(collection_id, item_id);20382039        ensure!(2040            sender == item.owner,2041            Error::<T>::MustBeTokenOwner2042        );20432044        // update balance2045        let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())2046            .checked_sub(1)2047            .ok_or(Error::<T>::NumOverflow)?;2048        <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);20492050        let balancenew_owner = <Balance<T>>::get(collection_id, new_owner.clone())2051            .checked_add(1)2052            .ok_or(Error::<T>::NumOverflow)?;2053        <Balance<T>>::insert(collection_id, new_owner.clone(), balancenew_owner);20542055        // change owner2056        let old_owner = item.owner.clone();2057        item.owner = new_owner.clone();2058        <NftItemList<T>>::insert(collection_id, item_id, item);20592060        // update index collection2061        Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;20622063        Ok(())2064    }2065    2066    fn set_re_fungible_variable_data(2067        collection_id: CollectionId,2068        item_id: TokenId,2069        data: Vec<u8>2070    ) -> DispatchResult {2071        let mut item = <ReFungibleItemList<T>>::get(collection_id, item_id);20722073        item.variable_data = data;20742075        <ReFungibleItemList<T>>::insert(collection_id, item_id, item);20762077        Ok(())2078    }20792080    fn set_nft_variable_data(2081        collection_id: CollectionId,2082        item_id: TokenId,2083        data: Vec<u8>2084    ) -> DispatchResult {2085        let mut item = <NftItemList<T>>::get(collection_id, item_id);2086        2087        item.variable_data = data;20882089        <NftItemList<T>>::insert(collection_id, item_id, item);2090        2091        Ok(())2092    }20932094    fn init_collection(item: &CollectionType<T::AccountId>) {2095        // check params2096        assert!(2097            item.decimal_points <= MAX_DECIMAL_POINTS,2098            "decimal_points parameter must be lower than MAX_DECIMAL_POINTS"2099        );2100        assert!(2101            item.name.len() <= 64,2102            "Collection name can not be longer than 63 char"2103        );2104        assert!(2105            item.name.len() <= 256,2106            "Collection description can not be longer than 255 char"2107        );2108        assert!(2109            item.token_prefix.len() <= 16,2110            "Token prefix can not be longer than 15 char"2111        );21122113        // Generate next collection ID2114        let next_id = CreatedCollectionCount::get()2115            .checked_add(1)2116            .unwrap();21172118        CreatedCollectionCount::put(next_id);2119    }21202121    fn init_nft_token(collection_id: CollectionId, item: &NftItemType<T::AccountId>) {2122        let current_index = <ItemListIndex>::get(collection_id)2123            .checked_add(1)2124            .unwrap();21252126        let item_owner = item.owner.clone();2127        Self::add_token_index(collection_id, current_index, &item.owner).unwrap();21282129        <ItemListIndex>::insert(collection_id, current_index);21302131        // Update balance2132        let new_balance = <Balance<T>>::get(collection_id, &item_owner)2133            .checked_add(1)2134            .unwrap();2135        <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);2136    }21372138    fn init_fungible_token(collection_id: CollectionId, owner: &T::AccountId, item: &FungibleItemType) {2139        let current_index = <ItemListIndex>::get(collection_id)2140            .checked_add(1)2141            .unwrap();21422143        Self::add_token_index(collection_id, current_index, owner).unwrap();21442145        <ItemListIndex>::insert(collection_id, current_index);21462147        // Update balance2148        let new_balance = <Balance<T>>::get(collection_id, owner)2149            .checked_add(item.value)2150            .unwrap();2151        <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);2152    }21532154    fn init_refungible_token(collection_id: CollectionId, item: &ReFungibleItemType<T::AccountId>) {2155        let current_index = <ItemListIndex>::get(collection_id)2156            .checked_add(1)2157            .unwrap();21582159        let value = item.owner.first().unwrap().fraction;2160        let owner = item.owner.first().unwrap().owner.clone();21612162        Self::add_token_index(collection_id, current_index, &owner).unwrap();21632164        <ItemListIndex>::insert(collection_id, current_index);21652166        // Update balance2167        let new_balance = <Balance<T>>::get(collection_id, &owner)2168            .checked_add(value)2169            .unwrap();2170        <Balance<T>>::insert(collection_id, owner.clone(), new_balance);2171    }21722173    fn add_token_index(collection_id: CollectionId, item_index: TokenId, owner: &T::AccountId) -> DispatchResult {21742175        // add to account limit2176        if <AccountItemCount<T>>::contains_key(owner) {21772178            // bound Owned tokens by a single address2179            let count = <AccountItemCount<T>>::get(owner);2180            ensure!(count < ChainLimit::get().account_token_ownership_limit, Error::<T>::AddressOwnershipLimitExceeded);21812182            <AccountItemCount<T>>::insert(owner.clone(), count2183                .checked_add(1)2184                .ok_or(Error::<T>::NumOverflow)?);2185        }2186        else {2187            <AccountItemCount<T>>::insert(owner.clone(), 1);2188        }21892190        let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner);2191        if list_exists {2192            let mut list = <AddressTokens<T>>::get(collection_id, owner);2193            let item_contains = list.contains(&item_index.clone());21942195            if !item_contains {2196                list.push(item_index.clone());2197            }21982199            <AddressTokens<T>>::insert(collection_id, owner.clone(), list);2200        } else {2201            let mut itm = Vec::new();2202            itm.push(item_index.clone());2203            <AddressTokens<T>>::insert(collection_id, owner.clone(), itm);2204        }22052206        Ok(())2207    }22082209    fn remove_token_index(2210        collection_id: CollectionId,2211        item_index: TokenId,2212        owner: &T::AccountId,2213    ) -> DispatchResult {22142215        // update counter2216        <AccountItemCount<T>>::insert(owner.clone(), 2217            <AccountItemCount<T>>::get(owner)2218            .checked_sub(1)2219            .ok_or(Error::<T>::NumOverflow)?);222022212222        let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner);2223        if list_exists {2224            let mut list = <AddressTokens<T>>::get(collection_id, owner);2225            let item_contains = list.contains(&item_index.clone());22262227            if item_contains {2228                list.retain(|&item| item != item_index);2229                <AddressTokens<T>>::insert(collection_id, owner.clone(), list);2230            }2231        }22322233        Ok(())2234    }22352236    fn move_token_index(2237        collection_id: CollectionId,2238        item_index: TokenId,2239        old_owner: &T::AccountId,2240        new_owner: &T::AccountId,2241    ) -> DispatchResult {2242        Self::remove_token_index(collection_id, item_index, old_owner)?;2243        Self::add_token_index(collection_id, item_index, new_owner)?;22442245        Ok(())2246    }2247    2248    fn ensure_contract_owned(account: T::AccountId, contract: &T::AccountId) -> DispatchResult {2249        if <ContractOwner<T>>::contains_key(contract.clone()) {2250            let owner = <ContractOwner<T>>::get(contract);2251            ensure!(account == owner, Error::<T>::NoPermission);2252        } else {2253            fail!(Error::<T>::NoPermission);2254        }22552256        Ok(())2257    }2258}22592260////////////////////////////////////////////////////////////////////////////////////////////////////2261// Economic models2262// #region22632264/// Fee multiplier.2265pub type Multiplier = FixedU128;22662267type BalanceOf<T> = <<T as transaction_payment::Config>::OnChargeTransaction as transaction_payment::OnChargeTransaction<T>>::Balance;22682269/// Require the transactor pay for themselves and maybe include a tip to gain additional priority2270/// in the queue.2271#[derive(Encode, Decode, Clone, Eq, PartialEq)]2272pub struct ChargeTransactionPayment<T: Config>(#[codec(compact)] BalanceOf<T>);22732274impl<T: Config + Send + Sync> sp_std::fmt::Debug 2275    for ChargeTransactionPayment<T>2276{2277	#[cfg(feature = "std")]2278	fn fmt(&self, f: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {2279		write!(f, "ChargeTransactionPayment<{:?}>", self.0)2280	}2281	#[cfg(not(feature = "std"))]2282	fn fmt(&self, _: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {2283		Ok(())2284	}2285}22862287impl<T: Config> ChargeTransactionPayment<T>2288where2289    T::Call: Dispatchable<Info=DispatchInfo, PostInfo=PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,2290    BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,2291    T::AccountId: AsRef<[u8]>,2292    T::AccountId: UncheckedFrom<T::Hash>,2293{2294    fn traditional_fee(2295        len: usize,2296        info: &DispatchInfoOf<T::Call>,2297        tip: BalanceOf<T>,2298    ) -> BalanceOf<T>2299    where2300        T::Call: Dispatchable<Info = DispatchInfo>,2301    {2302        <transaction_payment::Module<T>>::compute_fee(len as u32, info, tip)2303    }23042305	fn get_priority(len: usize, info: &DispatchInfoOf<T::Call>, final_fee: BalanceOf<T>) -> TransactionPriority {2306        let weight_saturation = T::BlockWeights::get().max_block / info.weight.max(1);2307        let max_block_length = *T::BlockLength::get().max.get(DispatchClass::Normal);2308        let len_saturation = max_block_length as u64 / (len as u64).max(1);2309        let coefficient: BalanceOf<T> = weight_saturation2310            .min(len_saturation)2311            .saturated_into::<BalanceOf<T>>();2312        final_fee2313            .saturating_mul(coefficient)2314            .saturated_into::<TransactionPriority>()2315    }23162317    fn withdraw_fee(2318        &self,2319        who: &T::AccountId,2320        call: &T::Call,2321        info: &DispatchInfoOf<T::Call>,2322        len: usize,2323	) -> Result<2324		(2325			BalanceOf<T>,2326			<<T as transaction_payment::Config>::OnChargeTransaction as transaction_payment::OnChargeTransaction<T>>::LiquidityInfo,2327		),2328		TransactionValidityError,2329	> {2330        let tip = self.0;23312332        // Set fee based on call type. Creating collection costs 1 Unique.2333        // All other transactions have traditional fees so far2334        // let fee = match call.is_sub_type() {2335        //     Some(Call::create_collection(..)) => <BalanceOf<T>>::from(1_000_000_000),2336        //     _ => Self::traditional_fee(len, info, tip), // Flat fee model, use only for testing purposes2337        //                                                 // _ => <BalanceOf<T>>::from(100)2338        // };2339        let fee = Self::traditional_fee(len, info, tip);23402341        // Only mess with balances if fee is not zero.2342        if fee.is_zero() {2343            return <<T as transaction_payment::Config>::OnChargeTransaction as transaction_payment::OnChargeTransaction<T>>::withdraw_fee(who, call, info, fee, tip)2344			.map(|i| (fee, i));2345        }23462347        // Determine who is paying transaction fee based on ecnomic model2348        // Parse call to extract collection ID and access collection sponsor2349        let mut sponsor: T::AccountId = match IsSubType::<Call<T>>::is_sub_type(call) {2350            Some(Call::create_item(collection_id, _owner, _properties)) => {23512352                // sponsor timeout2353                let block_number = <system::Module<T>>::block_number() as T::BlockNumber;23542355                let limit = <Collection<T>>::get(collection_id).limits.sponsor_transfer_timeout;2356                let mut sponsored = true;2357                if <CreateItemBasket<T>>::contains_key((collection_id, &who)) {2358                    let last_tx_block = <CreateItemBasket<T>>::get((collection_id, &who));2359                    let limit_time = last_tx_block + limit.into();2360                    if block_number <= limit_time {2361                        sponsored = false;2362                    }2363                }2364                if sponsored {2365                    <CreateItemBasket<T>>::insert((collection_id, who.clone()), block_number);2366                }23672368                // check free create limit2369                if (<Collection<T>>::get(collection_id).limits.sponsored_data_size >= (_properties.len() as u32)) &&2370                   (<Collection<T>>::get(collection_id).sponsor_confirmed) &&2371                   (sponsored)2372                {2373                    <Collection<T>>::get(collection_id).sponsor2374                } else {2375                    T::AccountId::default()2376                }2377            }2378            Some(Call::transfer(_new_owner, collection_id, item_id, _value)) => {2379                2380                let mut sponsor_transfer = false;2381                if <Collection<T>>::get(collection_id).sponsor_confirmed {23822383                    let collection_limits = <Collection<T>>::get(collection_id).limits;2384                    let collection_mode = <Collection<T>>::get(collection_id).mode;2385    2386                    // sponsor timeout2387                    let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2388                    sponsor_transfer = match collection_mode {2389                        CollectionMode::NFT => {2390    2391                            // get correct limit2392                            let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2393                                collection_limits.sponsor_transfer_timeout2394                            } else {2395                                ChainLimit::get().nft_sponsor_transfer_timeout2396                            };2397    2398                            let mut sponsored = true;2399                            if <NftTransferBasket<T>>::contains_key(collection_id, item_id) {2400                                let last_tx_block = <NftTransferBasket<T>>::get(collection_id, item_id);2401                                let limit_time = last_tx_block + limit.into();2402                                if block_number <= limit_time {2403                                    sponsored = false;2404                                }2405                            }2406                            if sponsored {2407                                <NftTransferBasket<T>>::insert(collection_id, item_id, block_number);2408                            }24092410                            sponsored2411                        }2412                        CollectionMode::Fungible(_) => {2413    2414                            // get correct limit2415                            let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2416                                collection_limits.sponsor_transfer_timeout2417                            } else {2418                                ChainLimit::get().fungible_sponsor_transfer_timeout2419                            };2420    2421                            let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2422                            let mut sponsored = true;2423                            if <FungibleTransferBasket<T>>::contains_key(collection_id, who) {2424                                let last_tx_block = <FungibleTransferBasket<T>>::get(collection_id, who);2425                                let limit_time = last_tx_block + limit.into();2426                                if block_number <= limit_time {2427                                    sponsored = false;2428                                }2429                            }2430                            if sponsored {2431                                <FungibleTransferBasket<T>>::insert(collection_id, who, block_number);2432                            }24332434                            sponsored2435                        }2436                        CollectionMode::ReFungible => {2437    2438                            // get correct limit2439                            let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2440                                collection_limits.sponsor_transfer_timeout2441                            } else {2442                                ChainLimit::get().refungible_sponsor_transfer_timeout2443                            };2444    2445                            let mut sponsored = true;2446                            if <ReFungibleTransferBasket<T>>::contains_key(collection_id, item_id) {2447                                let last_tx_block = <ReFungibleTransferBasket<T>>::get(collection_id, item_id);2448                                let limit_time = last_tx_block + limit.into();2449                                if block_number <= limit_time {2450                                    sponsored = false;2451                                }2452                            }2453                            if sponsored {2454                                <ReFungibleTransferBasket<T>>::insert(collection_id, item_id, block_number);2455                            }24562457                            sponsored2458                        }2459                        _ => {2460                            false2461                        },2462                    };2463                }24642465                if !sponsor_transfer {2466                    T::AccountId::default()2467                } else {2468                    <Collection<T>>::get(collection_id).sponsor2469                }2470            }24712472            _ => T::AccountId::default(),2473        };24742475        // Sponsor smart contracts2476        sponsor = match IsSubType::<pallet_contracts::Call<T>>::is_sub_type(call) {24772478            // On instantiation: set the contract owner2479            Some(pallet_contracts::Call::instantiate(_endowment, _gas_limit, code_hash, _data, salt)) => {24802481                let new_contract_address = <pallet_contracts::Module<T>>::contract_address(2482                    &who,2483                    code_hash,2484                    salt,2485                );2486                <ContractOwner<T>>::insert(new_contract_address.clone(), who.clone());24872488                T::AccountId::default()2489            },24902491            // When the contract is called, check if the sponsoring is enabled and pay fees from contract endowment if it is2492            Some(pallet_contracts::Call::call(dest, _value, _gas_limit, _data)) => {24932494                let called_contract: T::AccountId = T::Lookup::lookup((*dest).clone()).unwrap_or(T::AccountId::default());24952496                let owned_contract = <ContractOwner<T>>::contains_key(called_contract.clone())2497                  && <ContractOwner<T>>::get(called_contract.clone()) == *who;2498                let white_list_enabled = <ContractWhiteListEnabled<T>>::contains_key(called_contract.clone()) && <ContractWhiteListEnabled<T>>::get(called_contract.clone());2499                  2500                if !owned_contract && white_list_enabled {2501                    if !<ContractWhiteList<T>>::contains_key(called_contract.clone(), who) {2502                        return Err(InvalidTransaction::Call.into());2503                    }2504                }25052506                let mut sponsor_transfer = false;2507                if <ContractSponsoringRateLimit<T>>::contains_key(called_contract.clone()) {2508                    let last_tx_block = <ContractSponsorBasket<T>>::get((&called_contract, &who));2509                    let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2510                    let rate_limit = <ContractSponsoringRateLimit<T>>::get(&called_contract);2511                    let limit_time = last_tx_block + rate_limit;25122513                    if block_number >= limit_time {2514                        <ContractSponsorBasket<T>>::insert((called_contract.clone(), who.clone()), block_number);2515                        sponsor_transfer = true;2516                    }2517                } else {2518                    sponsor_transfer = false;2519                }2520               2521                2522                let mut sp = T::AccountId::default();2523                if sponsor_transfer {2524                    if <ContractSelfSponsoring<T>>::contains_key(called_contract.clone()) {2525                        if <ContractSelfSponsoring<T>>::get(called_contract.clone()) {2526                            sp = called_contract;2527                        }2528                    }2529                }25302531                sp2532            },25332534            _ => sponsor,2535        };25362537        let mut who_pays_fee: T::AccountId = sponsor.clone();2538        if sponsor == T::AccountId::default() {2539            who_pays_fee = who.clone();2540        }25412542		<<T as transaction_payment::Config>::OnChargeTransaction as transaction_payment::OnChargeTransaction<T>>::withdraw_fee(&who_pays_fee, call, info, fee, tip)2543			.map(|i| (fee, i))2544    }2545}254625472548impl<T: Config + Send + Sync> SignedExtension2549    for ChargeTransactionPayment<T>2550where2551    BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,2552    T::Call: Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,2553    T::AccountId: AsRef<[u8]>,2554    T::AccountId: UncheckedFrom<T::Hash>,2555{2556    const IDENTIFIER: &'static str = "ChargeTransactionPayment";2557    type AccountId = T::AccountId;2558    type Call = T::Call;2559    type AdditionalSigned = ();2560    type Pre = (2561        // tip2562        BalanceOf<T>,2563        // who pays fee2564        Self::AccountId,2565		// imbalance resulting from withdrawing the fee2566		<<T as transaction_payment::Config>::OnChargeTransaction as transaction_payment::OnChargeTransaction<T>>::LiquidityInfo,2567    );2568    fn additional_signed(&self) -> sp_std::result::Result<(), TransactionValidityError> {2569        Ok(())2570    }25712572    fn validate(2573        &self,2574        who: &Self::AccountId,2575        call: &Self::Call,2576        info: &DispatchInfoOf<Self::Call>,2577        len: usize,2578    ) -> TransactionValidity {2579		let (fee, _) = self.withdraw_fee(who, call, info, len)?;2580		Ok(ValidTransaction {2581			priority: Self::get_priority(len, info, fee),2582			..Default::default()2583		})2584    }25852586    fn pre_dispatch(2587        self,2588        who: &Self::AccountId,2589        call: &Self::Call,2590        info: &DispatchInfoOf<Self::Call>,2591        len: usize,2592    ) -> Result<Self::Pre, TransactionValidityError> {2593        let (_fee, imbalance) = self.withdraw_fee(who, call, info, len)?;2594        Ok((self.0, who.clone(), imbalance))2595    }25962597    fn post_dispatch(2598        pre: Self::Pre,2599        info: &DispatchInfoOf<Self::Call>,2600        post_info: &PostDispatchInfoOf<Self::Call>,2601        len: usize,2602        _result: &DispatchResult,2603    ) -> Result<(), TransactionValidityError> {2604		let (tip, who, imbalance) = pre;2605		let actual_fee = transaction_payment::Module::<T>::compute_actual_fee(2606			len as u32,2607			info,2608			post_info,2609			tip,2610		);2611		<T as transaction_payment::Config>::OnChargeTransaction::correct_and_deposit_fee(&who, info, post_info, actual_fee, tip, imbalance)?;2612		Ok(())2613    }2614}26152616// #endregion