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

1//2// This file is subject to the terms and conditions defined in3// file 'LICENSE', which is part of this source code package.4//56#![recursion_limit = "1024"]78#![cfg_attr(not(feature = "std"), no_std)]910#[cfg(feature = "std")]11pub use std::*;1213#[cfg(feature = "std")]14pub use serde::*;1516use codec::{Decode, Encode};17pub use frame_support::{18    construct_runtime, decl_event, decl_module, decl_storage, decl_error,19    dispatch::DispatchResult,20    ensure, fail, parameter_types,21    traits::{22        Currency, ExistenceRequirement, Get, Imbalance, KeyOwnerProofSystem, OnUnbalanced,23        Randomness, IsSubType,24    },25    weights::{26        constants::{BlockExecutionWeight, ExtrinsicBaseWeight, RocksDbWeight, WEIGHT_PER_SECOND},27        DispatchInfo, GetDispatchInfo, IdentityFee, Pays, PostDispatchInfo, Weight,28        WeightToFeePolynomial, DispatchClass,29    },30    StorageValue,31};3233use frame_system::{self as system, ensure_signed, ensure_root};34use sp_runtime::sp_std::prelude::Vec;35use sp_runtime::{36    traits::{37        Hash, DispatchInfoOf, Dispatchable, PostDispatchInfoOf, Saturating, SaturatedConversion, SignedExtension, Zero,38    },39    transaction_validity::{40        TransactionPriority, InvalidTransaction, TransactionValidity, TransactionValidityError, ValidTransaction,41    },42    FixedPointOperand, FixedU128,43};44use sp_runtime::traits::StaticLookup;45use pallet_contracts::chain_extension::UncheckedFrom;46use pallet_contracts::*;47use pallet_transaction_payment::OnChargeTransaction;4849#[cfg(test)]50mod mock;5152#[cfg(test)]53mod tests;5455mod default_weights;5657pub const MAX_DECIMAL_POINTS: DecimalPoints = 30;58pub const MAX_REFUNGIBLE_PIECES: u128 = 1_000_000_000_000_000_000_000;59pub const MAX_SPONSOR_TIMEOUT: u32 = 10_368_000;60pub const MAX_TOKEN_OWNERSHIP: u32 = 10_000_000;6162// Structs63// #region6465pub type CollectionId = u32;66pub type TokenId = u32;67pub type DecimalPoints = u8;6869#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq)]70#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]71pub enum CollectionMode {72    Invalid,73    NFT,74    // decimal points75    Fungible(DecimalPoints),76    ReFungible,77}7879impl Default for CollectionMode {80    fn default() -> Self {81        Self::Invalid82    }83}8485impl Into<u8> for CollectionMode {86    fn into(self) -> u8 {87        match self {88            CollectionMode::Invalid => 0,89            CollectionMode::NFT => 1,90            CollectionMode::Fungible(_) => 2,91            CollectionMode::ReFungible => 3,92        }93    }94}9596#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq)]97#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]98pub enum AccessMode {99    Normal,100    WhiteList,101}102impl Default for AccessMode {103    fn default() -> Self {104        Self::Normal105    }106}107108#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq)]109#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]110pub enum SchemaVersion {111    ImageURL,112    Unique,113}114impl Default for SchemaVersion {115    fn default() -> Self {116        Self::ImageURL117    }118}119120#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]121#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]122pub struct Ownership<AccountId> {123    pub owner: AccountId,124    pub fraction: u128,125}126127#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]128#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]129pub struct CollectionType<AccountId> {130    pub owner: AccountId,131    pub mode: CollectionMode,132    pub access: AccessMode,133    pub decimal_points: DecimalPoints,134    pub name: Vec<u16>,        // 64 include null escape char135    pub description: Vec<u16>, // 256 include null escape char136    pub token_prefix: Vec<u8>, // 16 include null escape char137    pub mint_mode: bool,138    pub offchain_schema: Vec<u8>,139    pub schema_version: SchemaVersion,140    pub sponsor: AccountId, // Who pays fees. If set to default address, the fees are applied to the transaction sender141    pub sponsor_confirmed: bool, // False if sponsor address has not yet confirmed sponsorship. True otherwise.142    pub limits: CollectionLimits, // Collection private restrictions 143    pub variable_on_chain_schema: Vec<u8>, //144    pub const_on_chain_schema: Vec<u8>, //145}146147#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]148#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]149pub struct NftItemType<AccountId> {150    pub owner: AccountId,151    pub const_data: Vec<u8>,152    pub variable_data: Vec<u8>,153}154155#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]156#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]157pub struct FungibleItemType {158    pub value: u128,159}160161#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]162#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]163pub struct ReFungibleItemType<AccountId> {164    pub owner: Vec<Ownership<AccountId>>,165    pub const_data: Vec<u8>,166    pub variable_data: Vec<u8>,167}168169// #[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]170// #[cfg_attr(feature = "std", derive(Serialize, Deserialize))]171// pub struct VestingItem<AccountId, Moment> {172//     pub sender: AccountId,173//     pub recipient: AccountId,174//     pub collection_id: CollectionId,175//     pub item_id: TokenId,176//     pub amount: u64,177//     pub vesting_date: Moment,178// }179180#[derive(Encode, Decode, Debug, Clone, PartialEq)]181#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]182pub struct CollectionLimits {183    pub account_token_ownership_limit: u32,184    pub sponsored_data_size: u32,185    pub token_limit: u32,186187    // Timeouts for item types in passed blocks188    pub sponsor_transfer_timeout: u32,189    pub owner_can_transfer: bool,190    pub owner_can_destroy: bool,191}192193impl Default for CollectionLimits {194    fn default() -> CollectionLimits {195        CollectionLimits { 196            account_token_ownership_limit: 10_000_000, 197            token_limit: u32::max_value(),198            sponsored_data_size: u32::MAX,199            sponsor_transfer_timeout: 14400,200            owner_can_transfer: true,201            owner_can_destroy: true202        }203    }204}205206#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]207#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]208pub struct ChainLimits {209    pub collection_numbers_limit: u32,210    pub account_token_ownership_limit: u32,211    pub collections_admins_limit: u64,212    pub custom_data_limit: u32,213214    // Timeouts for item types in passed blocks215    pub nft_sponsor_transfer_timeout: u32,216    pub fungible_sponsor_transfer_timeout: u32,217    pub refungible_sponsor_transfer_timeout: u32,218219    // Schema limits220    pub offchain_schema_limit: u32,221    pub variable_on_chain_schema_limit: u32,222    pub const_on_chain_schema_limit: u32,223}224225pub trait WeightInfo {226	fn create_collection() -> Weight;227	fn destroy_collection() -> Weight;228	fn add_to_white_list() -> Weight;229	fn remove_from_white_list() -> Weight;230    fn set_public_access_mode() -> Weight;231    fn set_mint_permission() -> Weight;232    fn change_collection_owner() -> Weight;233    fn add_collection_admin() -> Weight;234    fn remove_collection_admin() -> Weight;235    fn set_collection_sponsor() -> Weight;236    fn confirm_sponsorship() -> Weight;237    fn remove_collection_sponsor() -> Weight;238    fn create_item(s: usize) -> Weight;239    fn burn_item() -> Weight;240    fn transfer() -> Weight;241    fn approve() -> Weight;242    fn transfer_from() -> Weight;243    fn set_offchain_schema() -> Weight;244    fn set_const_on_chain_schema() -> Weight;245    fn set_variable_on_chain_schema() -> Weight;246    fn set_variable_meta_data() -> Weight;247    fn enable_contract_sponsoring() -> Weight;248    fn set_schema_version() -> Weight;249    fn set_chain_limits() -> Weight;250    fn set_contract_sponsoring_rate_limit() -> Weight;251    fn toggle_contract_white_list() -> Weight;252    fn add_to_contract_white_list() -> Weight;253    fn remove_from_contract_white_list() -> Weight;254    fn set_collection_limits() -> Weight;255}256257#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]258#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]259pub struct CreateNftData {260    pub const_data: Vec<u8>,261    pub variable_data: Vec<u8>,262}263264#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]265#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]266pub struct CreateFungibleData {267    pub value: u128,268}269270#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]271#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]272pub struct CreateReFungibleData {273    pub const_data: Vec<u8>,274    pub variable_data: Vec<u8>,275    pub pieces: u128,276}277278#[derive(Encode, Decode, Debug, Clone, PartialEq)]279#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]280pub enum CreateItemData {281    NFT(CreateNftData),282    Fungible(CreateFungibleData),283    ReFungible(CreateReFungibleData),284}285286impl CreateItemData {287    pub fn len(&self) -> usize {288        let len = match self {289            CreateItemData::NFT(data) => data.variable_data.len() + data.const_data.len(),290            CreateItemData::ReFungible(data) => data.variable_data.len() + data.const_data.len(),291            _ => 0292        };293        294        return len;295    }296}297298impl From<CreateNftData> for CreateItemData {299    fn from(item: CreateNftData) -> Self {300        CreateItemData::NFT(item)301    }302}303304impl From<CreateReFungibleData> for CreateItemData {305    fn from(item: CreateReFungibleData) -> Self {306        CreateItemData::ReFungible(item)307    }308}309310impl From<CreateFungibleData> for CreateItemData {311    fn from(item: CreateFungibleData) -> Self {312        CreateItemData::Fungible(item)313    }314}315316317decl_error! {318	/// Error for non-fungible-token module.319	pub enum Error for Module<T: Config> {320        /// Total collections bound exceeded.321        TotalCollectionsLimitExceeded,322		/// Decimal_points parameter must be lower than MAX_DECIMAL_POINTS constant, currently it is 30.323        CollectionDecimalPointLimitExceeded, 324        /// Collection name can not be longer than 63 char.325        CollectionNameLimitExceeded, 326        /// Collection description can not be longer than 255 char.327        CollectionDescriptionLimitExceeded, 328        /// Token prefix can not be longer than 15 char.329        CollectionTokenPrefixLimitExceeded,330        /// This collection does not exist.331        CollectionNotFound,332        /// Item not exists.333        TokenNotFound,334        /// Admin not found335        AdminNotFound,336        /// Arithmetic calculation overflow.337        NumOverflow,       338        /// Account already has admin role.339        AlreadyAdmin,  340        /// You do not own this collection.341        NoPermission,342        /// This address is not set as sponsor, use setCollectionSponsor first.343        ConfirmUnsetSponsorFail,344        /// Collection is not in mint mode.345        PublicMintingNotAllowed,346        /// Sender parameter and item owner must be equal.347        MustBeTokenOwner,348        /// Item balance not enough.349        TokenValueTooLow,350        /// Size of item is too large.351        NftSizeLimitExceeded,352        /// No approve found353        ApproveNotFound,354        /// Requested value more than approved.355        TokenValueNotEnough,356        /// Only approved addresses can call this method.357        ApproveRequired,358        /// Address is not in white list.359        AddresNotInWhiteList,360        /// Number of collection admins bound exceeded.361        CollectionAdminsLimitExceeded,362        /// Owned tokens by a single address bound exceeded.363        AddressOwnershipLimitExceeded,364        /// Length of items properties must be greater than 0.365        EmptyArgument,366        /// const_data exceeded data limit.367        TokenConstDataLimitExceeded,368        /// variable_data exceeded data limit.369        TokenVariableDataLimitExceeded,370        /// Not NFT item data used to mint in NFT collection.371        NotNftDataUsedToMintNftCollectionToken,372        /// Not Fungible item data used to mint in Fungible collection.373        NotFungibleDataUsedToMintFungibleCollectionToken,374        /// Not Re Fungible item data used to mint in Re Fungible collection.375        NotReFungibleDataUsedToMintReFungibleCollectionToken,376        /// Unexpected collection type.377        UnexpectedCollectionType,378        /// Can't store metadata in fungible tokens.379        CantStoreMetadataInFungibleTokens,380        /// Collection token limit exceeded381        CollectionTokenLimitExceeded,382        /// Account token limit exceeded per collection383        AccountTokenLimitExceeded,384        /// Collection limit bounds per collection exceeded385        CollectionLimitBoundsExceeded,386        /// Tried to enable permissions which are only permitted to be disabled387        OwnerPermissionsCantBeReverted,388        /// Schema data size limit bound exceeded389        SchemaDataLimitExceeded,390        /// Maximum refungibility exceeded391        WrongRefungiblePieces392	}393}394395pub trait Config: system::Config + Sized + pallet_transaction_payment::Config + pallet_contracts::Config {396    type Event: From<Event<Self>> + Into<<Self as system::Config>::Event>;397398    /// Weight information for extrinsics in this pallet.399	type WeightInfo: WeightInfo;400}401402#[cfg(feature = "runtime-benchmarks")]403mod benchmarking;404405// #endregion406407decl_storage! {408    trait Store for Module<T: Config> as Nft {409410        // Private members411        NextCollectionID: CollectionId;412        CreatedCollectionCount: u32;413        ChainVersion: u64;414        ItemListIndex: map hasher(identity) CollectionId => TokenId;415416        // Chain limits struct417        pub ChainLimit get(fn chain_limit) config(): ChainLimits;418419        // Bound counters420        CollectionCount: u32;421        pub AccountItemCount get(fn account_item_count): map hasher(twox_64_concat) T::AccountId => u32;422423        // Basic collections424        pub Collection get(fn collection) config(): map hasher(identity) CollectionId => CollectionType<T::AccountId>;425        pub AdminList get(fn admin_list_collection): map hasher(identity) CollectionId => Vec<T::AccountId>;426        pub WhiteList get(fn white_list): double_map hasher(identity) CollectionId, hasher(twox_64_concat) T::AccountId => bool;427428        /// Balance owner per collection map429        pub Balance get(fn balance_count): double_map hasher(identity) CollectionId, hasher(twox_64_concat) T::AccountId => u128;430431        /// second parameter: item id + owner account id + spender account id432        pub Allowances get(fn approved): double_map hasher(identity) CollectionId, hasher(twox_64_concat) (TokenId, T::AccountId, T::AccountId) => u128;433434        /// Item collections435        pub NftItemList get(fn nft_item_id) config(): double_map hasher(identity) CollectionId, hasher(identity) TokenId => NftItemType<T::AccountId>;436        pub FungibleItemList get(fn fungible_item_id) config(): double_map hasher(identity) CollectionId, hasher(twox_64_concat) T::AccountId => FungibleItemType;437        pub ReFungibleItemList get(fn refungible_item_id) config(): double_map hasher(identity) CollectionId, hasher(identity) TokenId => ReFungibleItemType<T::AccountId>;438439        /// Index list440        pub AddressTokens get(fn address_tokens): double_map hasher(identity) CollectionId, hasher(twox_64_concat) T::AccountId => Vec<TokenId>;441442        /// Tokens transfer baskets443        pub CreateItemBasket get(fn create_item_basket): map hasher(twox_64_concat) (CollectionId, T::AccountId) => T::BlockNumber;444        pub NftTransferBasket get(fn nft_transfer_basket): double_map hasher(identity) CollectionId, hasher(identity) TokenId => T::BlockNumber;445        pub FungibleTransferBasket get(fn fungible_transfer_basket): double_map hasher(identity) CollectionId, hasher(twox_64_concat) T::AccountId => T::BlockNumber;446        pub ReFungibleTransferBasket get(fn refungible_transfer_basket): double_map hasher(identity) CollectionId, hasher(identity) TokenId => T::BlockNumber;447448        // Contract Sponsorship and Ownership449        pub ContractOwner get(fn contract_owner): map hasher(twox_64_concat) T::AccountId => T::AccountId;450        pub ContractSelfSponsoring get(fn contract_self_sponsoring): map hasher(twox_64_concat) T::AccountId => bool;451        pub ContractSponsorBasket get(fn contract_sponsor_basket): map hasher(twox_64_concat) (T::AccountId, T::AccountId) => T::BlockNumber;452        pub ContractSponsoringRateLimit get(fn contract_sponsoring_rate_limit): map hasher(twox_64_concat) T::AccountId => T::BlockNumber;453        pub ContractWhiteListEnabled get(fn contract_white_list_enabled): map hasher(twox_64_concat) T::AccountId => bool; 454        pub ContractWhiteList get(fn contract_white_list): double_map hasher(twox_64_concat) T::AccountId, hasher(twox_64_concat) T::AccountId => bool; 455    }456    add_extra_genesis {457        build(|config: &GenesisConfig<T>| {458            // Modification of storage459            for (_num, _c) in &config.collection {460                <Module<T>>::init_collection(_c);461            }462463            for (_num, _c, _i) in &config.nft_item_id {464                <Module<T>>::init_nft_token(*_c, _i);465            }466467            for (collection_id, account_id, fungible_item) in &config.fungible_item_id {468                <Module<T>>::init_fungible_token(*collection_id, account_id, fungible_item);469            }470471            for (_num, _c, _i) in &config.refungible_item_id {472                <Module<T>>::init_refungible_token(*_c, _i);473            }474        })475    }476}477478decl_event!(479    pub enum Event<T>480    where481        AccountId = <T as system::Config>::AccountId,482    {483        /// New collection was created484        /// 485        /// # Arguments486        /// 487        /// * collection_id: Globally unique identifier of newly created collection.488        /// 489        /// * mode: [CollectionMode] converted into u8.490        /// 491        /// * account_id: Collection owner.492        Created(CollectionId, u8, AccountId),493494        /// New item was created.495        /// 496        /// # Arguments497        /// 498        /// * collection_id: Id of the collection where item was created.499        /// 500        /// * item_id: Id of an item. Unique within the collection.501        ///502        /// * recipient: Owner of newly created item 503        ItemCreated(CollectionId, TokenId, AccountId),504505        /// Collection item was burned.506        /// 507        /// # Arguments508        /// 509        /// collection_id.510        /// 511        /// item_id: Identifier of burned NFT.512        ItemDestroyed(CollectionId, TokenId),513514        /// Item was transferred515        ///516        /// * collection_id: Id of collection to which item is belong517        ///518        /// * item_id: Id of an item519        ///520        /// * sender: Original owner of item521        ///522        /// * recipient: New owner of item523        ///524        /// * amount: Always 1 for NFT525        Transfer(CollectionId, TokenId, AccountId, AccountId, u128),526    }527);528529decl_module! {530    pub struct Module<T: Config> for enum Call 531    where 532        origin: T::Origin533    {534        fn deposit_event() = default;535        type Error = Error<T>;536537        fn on_initialize(now: T::BlockNumber) -> Weight {538539            if ChainVersion::get() < 2540            {541                let value = NextCollectionID::get();542                CreatedCollectionCount::put(value);543                ChainVersion::put(2);544            }545546            0547        }548549        /// 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.550        /// 551        /// # Permissions552        /// 553        /// * Anyone.554        /// 555        /// # Arguments556        /// 557        /// * collection_name: UTF-16 string with collection name (limit 64 characters), will be stored as zero-terminated.558        /// 559        /// * collection_description: UTF-16 string with collection description (limit 256 characters), will be stored as zero-terminated.560        /// 561        /// * token_prefix: UTF-8 string with token prefix.562        /// 563        /// * mode: [CollectionMode] collection type and type dependent data.564        // returns collection ID565        #[weight = <T as Config>::WeightInfo::create_collection()]566        pub fn create_collection(origin,567                                 collection_name: Vec<u16>,568                                 collection_description: Vec<u16>,569                                 token_prefix: Vec<u8>,570                                 mode: CollectionMode) -> DispatchResult {571572            // Anyone can create a collection573            let who = ensure_signed(origin)?;574575            let decimal_points = match mode {576                CollectionMode::Fungible(points) => points,577                _ => 0578            };579580            let chain_limit = ChainLimit::get();581582            // bound Total number of collections583            ensure!(CollectionCount::get() < chain_limit.collection_numbers_limit, Error::<T>::TotalCollectionsLimitExceeded);584585            // check params586            ensure!(decimal_points <= MAX_DECIMAL_POINTS, Error::<T>::CollectionDecimalPointLimitExceeded);587            ensure!(collection_name.len() <= 64, Error::<T>::CollectionNameLimitExceeded);588            ensure!(collection_description.len() <= 256, Error::<T>::CollectionDescriptionLimitExceeded);589            ensure!(token_prefix.len() <= 16, Error::<T>::CollectionTokenPrefixLimitExceeded);590591            // Generate next collection ID592            let next_id = CreatedCollectionCount::get()593                .checked_add(1)594                .ok_or(Error::<T>::NumOverflow)?;595596            // bound counter597            let total = CollectionCount::get()598                .checked_add(1)599                .ok_or(Error::<T>::NumOverflow)?;600601            CreatedCollectionCount::put(next_id);602            CollectionCount::put(total);603604            let limits = CollectionLimits {605                sponsored_data_size: chain_limit.custom_data_limit,606                ..Default::default()607            };608609            // Create new collection610            let new_collection = CollectionType {611                owner: who.clone(),612                name: collection_name,613                mode: mode.clone(),614                mint_mode: false,615                access: AccessMode::Normal,616                description: collection_description,617                decimal_points: decimal_points,618                token_prefix: token_prefix,619                offchain_schema: Vec::new(),620                schema_version: SchemaVersion::ImageURL,621                sponsor: T::AccountId::default(),622                sponsor_confirmed: false,623                variable_on_chain_schema: Vec::new(),624                const_on_chain_schema: Vec::new(),625                limits,626            };627628            // Add new collection to map629            <Collection<T>>::insert(next_id, new_collection);630631            // call event632            Self::deposit_event(RawEvent::Created(next_id, mode.into(), who.clone()));633634            Ok(())635        }636637        /// **DANGEROUS**: Destroys collection and all NFTs within this collection. Users irrecoverably lose their assets and may lose real money.638        /// 639        /// # Permissions640        /// 641        /// * Collection Owner.642        /// 643        /// # Arguments644        /// 645        /// * collection_id: collection to destroy.646        #[weight = <T as Config>::WeightInfo::destroy_collection()]647        pub fn destroy_collection(origin, collection_id: CollectionId) -> DispatchResult {648649            let sender = ensure_signed(origin)?;650            Self::check_owner_permissions(collection_id, sender)?;651652            let target_collection = <Collection<T>>::get(collection_id);653            if !target_collection.limits.owner_can_destroy {654                fail!(Error::<T>::NoPermission);655            }656657            <AddressTokens<T>>::remove_prefix(collection_id);658            <Allowances<T>>::remove_prefix(collection_id);659            <Balance<T>>::remove_prefix(collection_id);660            <ItemListIndex>::remove(collection_id);661            <AdminList<T>>::remove(collection_id);662            <Collection<T>>::remove(collection_id);663            <WhiteList<T>>::remove_prefix(collection_id);664665            <NftItemList<T>>::remove_prefix(collection_id);666            <FungibleItemList<T>>::remove_prefix(collection_id);667            <ReFungibleItemList<T>>::remove_prefix(collection_id);668669            <NftTransferBasket<T>>::remove_prefix(collection_id);670            <FungibleTransferBasket<T>>::remove_prefix(collection_id);671            <ReFungibleTransferBasket<T>>::remove_prefix(collection_id);672673            if CollectionCount::get() > 0674            {675                // bound couter676                let total = CollectionCount::get()677                    .checked_sub(1)678                    .ok_or(Error::<T>::NumOverflow)?;679680                CollectionCount::put(total);681            }682683            Ok(())684        }685686        /// Add an address to white list.687        /// 688        /// # Permissions689        /// 690        /// * Collection Owner691        /// * Collection Admin692        /// 693        /// # Arguments694        /// 695        /// * collection_id.696        /// 697        /// * address.698        #[weight = <T as Config>::WeightInfo::add_to_white_list()]699        pub fn add_to_white_list(origin, collection_id: CollectionId, address: T::AccountId) -> DispatchResult{700701            let sender = ensure_signed(origin)?;702            Self::check_owner_or_admin_permissions(collection_id, sender)?;703704            <WhiteList<T>>::insert(collection_id, address, true);705            706            Ok(())707        }708709        /// Remove an address from white list.710        /// 711        /// # Permissions712        /// 713        /// * Collection Owner714        /// * Collection Admin715        /// 716        /// # Arguments717        /// 718        /// * collection_id.719        /// 720        /// * address.721        #[weight = <T as Config>::WeightInfo::remove_from_white_list()]722        pub fn remove_from_white_list(origin, collection_id: CollectionId, address: T::AccountId) -> DispatchResult{723724            let sender = ensure_signed(origin)?;725            Self::check_owner_or_admin_permissions(collection_id, sender)?;726727            <WhiteList<T>>::remove(collection_id, address);728729            Ok(())730        }731732        /// Toggle between normal and white list access for the methods with access for `Anyone`.733        /// 734        /// # Permissions735        /// 736        /// * Collection Owner.737        /// 738        /// # Arguments739        /// 740        /// * collection_id.741        /// 742        /// * mode: [AccessMode]743        #[weight = <T as Config>::WeightInfo::set_public_access_mode()]744        pub fn set_public_access_mode(origin, collection_id: CollectionId, mode: AccessMode) -> DispatchResult745        {746            let sender = ensure_signed(origin)?;747748            Self::check_owner_permissions(collection_id, sender)?;749            let mut target_collection = <Collection<T>>::get(collection_id);750            target_collection.access = mode;751            <Collection<T>>::insert(collection_id, target_collection);752753            Ok(())754        }755756        /// Allows Anyone to create tokens if:757        /// * White List is enabled, and758        /// * Address is added to white list, and759        /// * This method was called with True parameter760        /// 761        /// # Permissions762        /// * Collection Owner763        ///764        /// # Arguments765        /// 766        /// * collection_id.767        /// 768        /// * mint_permission: Boolean parameter. If True, allows minting to Anyone with conditions above.769        #[weight = <T as Config>::WeightInfo::set_mint_permission()]770        pub fn set_mint_permission(origin, collection_id: CollectionId, mint_permission: bool) -> DispatchResult771        {772            let sender = ensure_signed(origin)?;773774            Self::check_owner_permissions(collection_id, sender)?;775            let mut target_collection = <Collection<T>>::get(collection_id);776            target_collection.mint_mode = mint_permission;777            <Collection<T>>::insert(collection_id, target_collection);778779            Ok(())780        }781782        /// Change the owner of the collection.783        /// 784        /// # Permissions785        /// 786        /// * Collection Owner.787        /// 788        /// # Arguments789        /// 790        /// * collection_id.791        /// 792        /// * new_owner.793        #[weight = <T as Config>::WeightInfo::change_collection_owner()]794        pub fn change_collection_owner(origin, collection_id: CollectionId, new_owner: T::AccountId) -> DispatchResult {795796            let sender = ensure_signed(origin)?;797            Self::check_owner_permissions(collection_id, sender)?;798            let mut target_collection = <Collection<T>>::get(collection_id);799            target_collection.owner = new_owner;800            <Collection<T>>::insert(collection_id, target_collection);801802            Ok(())803        }804805        /// Adds an admin of the Collection.806        /// 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. 807        /// 808        /// # Permissions809        /// 810        /// * Collection Owner.811        /// * Collection Admin.812        /// 813        /// # Arguments814        /// 815        /// * collection_id: ID of the Collection to add admin for.816        /// 817        /// * new_admin_id: Address of new admin to add.818        #[weight = <T as Config>::WeightInfo::add_collection_admin()]819        pub fn add_collection_admin(origin, collection_id: CollectionId, new_admin_id: T::AccountId) -> DispatchResult {820821            let sender = ensure_signed(origin)?;822            Self::check_owner_or_admin_permissions(collection_id, sender)?;823            let mut admin_arr: Vec<T::AccountId> = Vec::new();824825            if <AdminList<T>>::contains_key(collection_id)826            {827                admin_arr = <AdminList<T>>::get(collection_id);828                ensure!(!admin_arr.contains(&new_admin_id), Error::<T>::AlreadyAdmin);829            }830831            // Number of collection admins832            ensure!((admin_arr.len() as u64) < ChainLimit::get().collections_admins_limit, Error::<T>::CollectionAdminsLimitExceeded);833834            admin_arr.push(new_admin_id);835            <AdminList<T>>::insert(collection_id, admin_arr);836837            Ok(())838        }839840        /// 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.841        ///842        /// # Permissions843        /// 844        /// * Collection Owner.845        /// * Collection Admin.846        /// 847        /// # Arguments848        /// 849        /// * collection_id: ID of the Collection to remove admin for.850        /// 851        /// * account_id: Address of admin to remove.852        #[weight = <T as Config>::WeightInfo::remove_collection_admin()]853        pub fn remove_collection_admin(origin, collection_id: CollectionId, account_id: T::AccountId) -> DispatchResult {854855            let sender = ensure_signed(origin)?;856            Self::check_owner_or_admin_permissions(collection_id, sender)?;857            ensure!(<AdminList<T>>::contains_key(collection_id), Error::<T>::AdminNotFound);858859            let mut admin_arr = <AdminList<T>>::get(collection_id);860            admin_arr.retain(|i| *i != account_id);861            <AdminList<T>>::insert(collection_id, admin_arr);862863            Ok(())864        }865866        /// # Permissions867        /// 868        /// * Collection Owner869        /// 870        /// # Arguments871        /// 872        /// * collection_id.873        /// 874        /// * new_sponsor.875        #[weight = <T as Config>::WeightInfo::set_collection_sponsor()]876        pub fn set_collection_sponsor(origin, collection_id: CollectionId, new_sponsor: T::AccountId) -> DispatchResult {877878            let sender = ensure_signed(origin)?;879            ensure!(<Collection<T>>::contains_key(collection_id), Error::<T>::CollectionNotFound);880881            let mut target_collection = <Collection<T>>::get(collection_id);882            ensure!(sender == target_collection.owner, Error::<T>::NoPermission);883884            target_collection.sponsor = new_sponsor;885            target_collection.sponsor_confirmed = false;886            <Collection<T>>::insert(collection_id, target_collection);887888            Ok(())889        }890891        /// # Permissions892        /// 893        /// * Sponsor.894        /// 895        /// # Arguments896        /// 897        /// * collection_id.898        #[weight = <T as Config>::WeightInfo::confirm_sponsorship()]899        pub fn confirm_sponsorship(origin, collection_id: CollectionId) -> DispatchResult {900901            let sender = ensure_signed(origin)?;902            ensure!(<Collection<T>>::contains_key(collection_id), Error::<T>::CollectionNotFound);903904            let mut target_collection = <Collection<T>>::get(collection_id);905            ensure!(sender == target_collection.sponsor, Error::<T>::ConfirmUnsetSponsorFail);906907            target_collection.sponsor_confirmed = true;908            <Collection<T>>::insert(collection_id, target_collection);909910            Ok(())911        }912913        /// Switch back to pay-per-own-transaction model.914        ///915        /// # Permissions916        ///917        /// * Collection owner.918        /// 919        /// # Arguments920        /// 921        /// * collection_id.922        #[weight = <T as Config>::WeightInfo::remove_collection_sponsor()]923        pub fn remove_collection_sponsor(origin, collection_id: CollectionId) -> DispatchResult {924925            let sender = ensure_signed(origin)?;926            ensure!(<Collection<T>>::contains_key(collection_id), Error::<T>::CollectionNotFound);927928            let mut target_collection = <Collection<T>>::get(collection_id);929            ensure!(sender == target_collection.owner, Error::<T>::NoPermission);930931            target_collection.sponsor = T::AccountId::default();932            target_collection.sponsor_confirmed = false;933            <Collection<T>>::insert(collection_id, target_collection);934935            Ok(())936        }937938        /// This method creates a concrete instance of NFT Collection created with CreateCollection method.939        /// 940        /// # Permissions941        /// 942        /// * Collection Owner.943        /// * Collection Admin.944        /// * Anyone if945        ///     * White List is enabled, and946        ///     * Address is added to white list, and947        ///     * MintPermission is enabled (see SetMintPermission method)948        /// 949        /// # Arguments950        /// 951        /// * collection_id: ID of the collection.952        /// 953        /// * owner: Address, initial owner of the NFT.954        ///955        /// * data: Token data to store on chain.956        // #[weight =957        // (130_000_000 as Weight)958        // .saturating_add((2135 as Weight).saturating_mul((properties.len() as u64) as Weight))959        // .saturating_add(RocksDbWeight::get().reads(10 as Weight))960        // .saturating_add(RocksDbWeight::get().writes(8 as Weight))]961962        #[weight = <T as Config>::WeightInfo::create_item(data.len())]963        pub fn create_item(origin, collection_id: CollectionId, owner: T::AccountId, data: CreateItemData) -> DispatchResult {964965            let sender = ensure_signed(origin)?;966967            Self::collection_exists(collection_id)?;968969            let target_collection = <Collection<T>>::get(collection_id);970971            Self::can_create_items_in_collection(collection_id, &target_collection, &sender, &owner)?;972            Self::validate_create_item_args(&target_collection, &data)?;973            Self::create_item_no_validation(collection_id, owner, data)?;974975            Ok(())976        }977978        /// This method creates multiple instances of NFT Collection created with CreateCollection method.979        /// 980        /// # Permissions981        /// 982        /// * Collection Owner.983        /// * Collection Admin.984        /// * Anyone if985        ///     * White List is enabled, and986        ///     * Address is added to white list, and987        ///     * MintPermission is enabled (see SetMintPermission method)988        /// 989        /// # Arguments990        /// 991        /// * collection_id: ID of the collection.992        /// 993        /// * itemsData: Array items properties. Each property is an array of bytes itself, see [create_item].994        /// 995        /// * owner: Address, initial owner of the NFT.996        #[weight = <T as Config>::WeightInfo::create_item(items_data.into_iter()997                               .map(|data| { data.len() })998                               .sum())]999        pub fn create_multiple_items(origin, collection_id: CollectionId, owner: T::AccountId, items_data: Vec<CreateItemData>) -> DispatchResult {10001001            ensure!(items_data.len() > 0, Error::<T>::EmptyArgument);1002            let sender = ensure_signed(origin)?;10031004            Self::collection_exists(collection_id)?;1005            let target_collection = <Collection<T>>::get(collection_id);10061007            Self::can_create_items_in_collection(collection_id, &target_collection, &sender, &owner)?;10081009            for data in &items_data {1010                Self::validate_create_item_args(&target_collection, data)?;1011            }1012            for data in &items_data {1013                Self::create_item_no_validation(collection_id, owner.clone(), data.clone())?;1014            }10151016            Ok(())1017        }10181019        /// Destroys a concrete instance of NFT.1020        /// 1021        /// # Permissions1022        /// 1023        /// * Collection Owner.1024        /// * Collection Admin.1025        /// * Current NFT Owner.1026        /// 1027        /// # Arguments1028        /// 1029        /// * collection_id: ID of the collection.1030        /// 1031        /// * item_id: ID of NFT to burn.1032        #[weight = <T as Config>::WeightInfo::burn_item()]1033        pub fn burn_item(origin, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {10341035            let sender = ensure_signed(origin)?;1036            Self::collection_exists(collection_id)?;10371038            // Transfer permissions check1039            let target_collection = <Collection<T>>::get(collection_id);1040            ensure!(1041                Self::is_item_owner(sender.clone(), collection_id, item_id) ||1042                (1043                    target_collection.limits.owner_can_transfer &&1044                    Self::is_owner_or_admin_permissions(collection_id, sender.clone())1045                ),1046                Error::<T>::NoPermission1047            );10481049            if target_collection.access == AccessMode::WhiteList {1050                Self::check_white_list(collection_id, &sender)?;1051            }10521053            match target_collection.mode1054            {1055                CollectionMode::NFT => Self::burn_nft_item(collection_id, item_id)?,1056                CollectionMode::Fungible(_)  => Self::burn_fungible_item(&sender, collection_id, value)?,1057                CollectionMode::ReFungible  => Self::burn_refungible_item(collection_id, item_id, &sender)?,1058                _ => ()1059            };10601061            // call event1062            Self::deposit_event(RawEvent::ItemDestroyed(collection_id, item_id));10631064            Ok(())1065        }10661067        /// Change ownership of the token.1068        /// 1069        /// # Permissions1070        /// 1071        /// * Collection Owner1072        /// * Collection Admin1073        /// * Current NFT owner1074        ///1075        /// # Arguments1076        /// 1077        /// * recipient: Address of token recipient.1078        /// 1079        /// * collection_id.1080        /// 1081        /// * item_id: ID of the item1082        ///     * Non-Fungible Mode: Required.1083        ///     * Fungible Mode: Ignored.1084        ///     * Re-Fungible Mode: Required.1085        /// 1086        /// * value: Amount to transfer.1087        ///     * Non-Fungible Mode: Ignored1088        ///     * Fungible Mode: Must specify transferred amount1089        ///     * Re-Fungible Mode: Must specify transferred portion (between 0 and 1)1090        #[weight = <T as Config>::WeightInfo::transfer()]1091        pub fn transfer(origin, recipient: T::AccountId, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {1092            let sender = ensure_signed(origin)?;1093            Self::transfer_internal(sender, recipient, collection_id, item_id, value)1094        }10951096        /// Set, change, or remove approved address to transfer the ownership of the NFT.1097        /// 1098        /// # Permissions1099        /// 1100        /// * Collection Owner1101        /// * Collection Admin1102        /// * Current NFT owner1103        /// 1104        /// # Arguments1105        /// 1106        /// * approved: Address that is approved to transfer this NFT or zero (if needed to remove approval).1107        /// 1108        /// * collection_id.1109        /// 1110        /// * item_id: ID of the item.1111        #[weight = <T as Config>::WeightInfo::approve()]1112        pub fn approve(origin, spender: T::AccountId, collection_id: CollectionId, item_id: TokenId, amount: u128) -> DispatchResult {11131114            let sender = ensure_signed(origin)?;11151116            Self::collection_exists(collection_id)?;1117            Self::token_exists(collection_id, item_id, &sender)?;11181119            // Transfer permissions check1120            let target_collection = <Collection<T>>::get(collection_id);1121            let allowance_limit = if (1122                target_collection.limits.owner_can_transfer &&1123                Self::is_owner_or_admin_permissions(1124                    collection_id,1125                    sender.clone(),1126                )1127            ) {1128                None1129            } else if let Some(amount) = Self::owned_amount(1130                sender.clone(),1131                collection_id,1132                item_id,1133            ) {1134                Some(amount)1135            } else {1136                fail!(Error::<T>::NoPermission);1137            };11381139            if target_collection.access == AccessMode::WhiteList {1140                Self::check_white_list(collection_id, &sender)?;1141                Self::check_white_list(collection_id, &spender)?;1142            }11431144            let allowance_exists = <Allowances<T>>::contains_key(collection_id, (item_id, &sender, &spender));1145            let mut allowance: u128 = amount;1146            if allowance_exists {1147                allowance += <Allowances<T>>::get(collection_id, (item_id, &sender, &spender));1148            }1149            if let Some(limit) = allowance_limit {1150                ensure!(limit >= allowance, Error::<T>::TokenValueTooLow);1151            }1152            <Allowances<T>>::insert(collection_id, (item_id, sender.clone(), spender.clone()), allowance);11531154            Ok(())1155        }1156        1157        /// Change ownership of a NFT on behalf of the owner. See Approve method for additional information. After this method executes, the approval is removed so that the approved address will not be able to transfer this NFT again from this owner.1158        /// 1159        /// # Permissions1160        /// * Collection Owner1161        /// * Collection Admin1162        /// * Current NFT owner1163        /// * Address approved by current NFT owner1164        /// 1165        /// # Arguments1166        /// 1167        /// * from: Address that owns token.1168        /// 1169        /// * recipient: Address of token recipient.1170        /// 1171        /// * collection_id.1172        /// 1173        /// * item_id: ID of the item.1174        /// 1175        /// * value: Amount to transfer.1176        #[weight = <T as Config>::WeightInfo::transfer_from()]1177        pub fn transfer_from(origin, from: T::AccountId, recipient: T::AccountId, collection_id: CollectionId, item_id: TokenId, value: u128 ) -> DispatchResult {11781179            let sender = ensure_signed(origin)?;1180            let mut appoved_transfer = false;11811182            // Check approval1183            let mut approval: u128 = 0;1184            if <Allowances<T>>::contains_key(collection_id, (item_id, &from, &sender)) {1185                approval = <Allowances<T>>::get(collection_id, (item_id, &from, &sender));1186                ensure!(approval >= value, Error::<T>::TokenValueNotEnough);1187                appoved_transfer = true;1188            }11891190            let target_collection = <Collection<T>>::get(collection_id);11911192            // Limits check1193            Self::is_correct_transfer(collection_id, &target_collection, &recipient)?;11941195            // Transfer permissions check         1196            ensure!(1197                appoved_transfer || 1198                (1199                    target_collection.limits.owner_can_transfer &&1200                    Self::is_owner_or_admin_permissions(collection_id, sender.clone())1201                ),1202                Error::<T>::NoPermission1203            );12041205            if target_collection.access == AccessMode::WhiteList {1206                Self::check_white_list(collection_id, &sender)?;1207                Self::check_white_list(collection_id, &recipient)?;1208            }12091210            // Reduce approval by transferred amount or remove if remaining approval drops to 01211            if approval.checked_sub(value).unwrap_or(0) > 0 {1212                <Allowances<T>>::insert(collection_id, (item_id, &from, &sender), approval - value);1213            }1214            else {1215                <Allowances<T>>::remove(collection_id, (item_id, &from, &sender));1216            }12171218            match target_collection.mode1219            {1220                CollectionMode::NFT => Self::transfer_nft(collection_id, item_id, from, recipient)?,1221                CollectionMode::Fungible(_)  => Self::transfer_fungible(collection_id, value, &from, &recipient)?,1222                CollectionMode::ReFungible  => Self::transfer_refungible(collection_id, item_id, value, from.clone(), recipient)?,1223                _ => ()1224            };12251226            Ok(())1227        }12281229        // #[weight = 0]1230        // pub fn safe_transfer_from(origin, collection_id: CollectionId, item_id: TokenId, new_owner: T::AccountId) -> DispatchResult {12311232        //     // let no_perm_mes = "You do not have permissions to modify this collection";1233        //     // ensure!(<ApprovedList<T>>::contains_key((collection_id, item_id)), no_perm_mes);1234        //     // let list_itm = <ApprovedList<T>>::get((collection_id, item_id));1235        //     // ensure!(list_itm.contains(&new_owner.clone()), no_perm_mes);12361237        //     // // on_nft_received  call12381239        //     // Self::transfer(origin, collection_id, item_id, new_owner)?;12401241        //     Ok(())1242        // }12431244        /// Set off-chain data schema.1245        /// 1246        /// # Permissions1247        /// 1248        /// * Collection Owner1249        /// * Collection Admin1250        /// 1251        /// # Arguments1252        /// 1253        /// * collection_id.1254        /// 1255        /// * schema: String representing the offchain data schema.1256        #[weight = <T as Config>::WeightInfo::set_variable_meta_data()]1257        pub fn set_variable_meta_data (1258            origin,1259            collection_id: CollectionId,1260            item_id: TokenId,1261            data: Vec<u8>1262        ) -> DispatchResult {1263            let sender = ensure_signed(origin)?;1264            1265            Self::collection_exists(collection_id)?;1266            Self::token_exists(collection_id, item_id, &sender)?;12671268            ensure!(ChainLimit::get().custom_data_limit >= data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);12691270            // Modify permissions check1271            let target_collection = <Collection<T>>::get(collection_id);1272            ensure!(Self::is_item_owner(sender.clone(), collection_id, item_id) ||1273                Self::is_owner_or_admin_permissions(collection_id, sender.clone()),1274                Error::<T>::NoPermission);12751276            match target_collection.mode1277            {1278                CollectionMode::NFT => Self::set_nft_variable_data(collection_id, item_id, data)?,1279                CollectionMode::ReFungible  => Self::set_re_fungible_variable_data(collection_id, item_id, data)?,1280                CollectionMode::Fungible(_) => fail!(Error::<T>::CantStoreMetadataInFungibleTokens),1281                _ => fail!(Error::<T>::UnexpectedCollectionType)1282            };12831284            Ok(())1285        }1286 1287        /// Set schema standard1288        /// ImageURL1289        /// Unique1290        /// 1291        /// # Permissions1292        /// 1293        /// * Collection Owner1294        /// * Collection Admin1295        /// 1296        /// # Arguments1297        /// 1298        /// * collection_id.1299        /// 1300        /// * schema: SchemaVersion: enum1301        #[weight = <T as Config>::WeightInfo::set_schema_version()]1302        pub fn set_schema_version(1303            origin,1304            collection_id: CollectionId,1305            version: SchemaVersion1306        ) -> DispatchResult {1307            let sender = ensure_signed(origin)?;1308            Self::check_owner_or_admin_permissions(collection_id, sender.clone())?;1309            let mut target_collection = <Collection<T>>::get(collection_id);1310            target_collection.schema_version = version;1311            <Collection<T>>::insert(collection_id, target_collection);13121313            Ok(())1314        }13151316        /// Set off-chain data schema.1317        /// 1318        /// # Permissions1319        /// 1320        /// * Collection Owner1321        /// * Collection Admin1322        /// 1323        /// # Arguments1324        /// 1325        /// * collection_id.1326        /// 1327        /// * schema: String representing the offchain data schema.1328        #[weight = <T as Config>::WeightInfo::set_offchain_schema()]1329        pub fn set_offchain_schema(1330            origin,1331            collection_id: CollectionId,1332            schema: Vec<u8>1333        ) -> DispatchResult {1334            let sender = ensure_signed(origin)?;1335            Self::check_owner_or_admin_permissions(collection_id, sender.clone())?;13361337            // check schema limit1338            ensure!(schema.len() as u32 <= ChainLimit::get().offchain_schema_limit, "");13391340            let mut target_collection = <Collection<T>>::get(collection_id);1341            target_collection.offchain_schema = schema;1342            <Collection<T>>::insert(collection_id, target_collection);13431344            Ok(())1345        }13461347        /// Set const on-chain data schema.1348        /// 1349        /// # Permissions1350        /// 1351        /// * Collection Owner1352        /// * Collection Admin1353        /// 1354        /// # Arguments1355        /// 1356        /// * collection_id.1357        /// 1358        /// * schema: String representing the const on-chain data schema.1359        #[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1360        pub fn set_const_on_chain_schema (1361            origin,1362            collection_id: CollectionId,1363            schema: Vec<u8>1364        ) -> DispatchResult {1365            let sender = ensure_signed(origin)?;1366            Self::check_owner_or_admin_permissions(collection_id, sender.clone())?;13671368            // check schema limit1369            ensure!(schema.len() as u32 <= ChainLimit::get().const_on_chain_schema_limit, "");13701371            let mut target_collection = <Collection<T>>::get(collection_id);1372            target_collection.const_on_chain_schema = schema;1373            <Collection<T>>::insert(collection_id, target_collection);13741375            Ok(())1376        }13771378        /// Set variable on-chain data schema.1379        /// 1380        /// # Permissions1381        /// 1382        /// * Collection Owner1383        /// * Collection Admin1384        /// 1385        /// # Arguments1386        /// 1387        /// * collection_id.1388        /// 1389        /// * schema: String representing the variable on-chain data schema.1390        #[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1391        pub fn set_variable_on_chain_schema (1392            origin,1393            collection_id: CollectionId,1394            schema: Vec<u8>1395        ) -> DispatchResult {1396            let sender = ensure_signed(origin)?;1397            Self::check_owner_or_admin_permissions(collection_id, sender.clone())?;13981399            // check schema limit1400            ensure!(schema.len() as u32 <= ChainLimit::get().variable_on_chain_schema_limit, "");14011402            let mut target_collection = <Collection<T>>::get(collection_id);1403            target_collection.variable_on_chain_schema = schema;1404            <Collection<T>>::insert(collection_id, target_collection);14051406            Ok(())1407        }14081409        // Sudo permissions function1410        #[weight = <T as Config>::WeightInfo::set_chain_limits()]1411        pub fn set_chain_limits(1412            origin,1413            limits: ChainLimits1414        ) -> DispatchResult {14151416            #[cfg(not(feature = "runtime-benchmarks"))]1417            ensure_root(origin)?;14181419            <ChainLimit>::put(limits);1420            Ok(())1421        }14221423        /// Enable smart contract self-sponsoring.1424        /// 1425        /// # Permissions1426        /// 1427        /// * Contract Owner1428        /// 1429        /// # Arguments1430        /// 1431        /// * contract address1432        /// * enable flag1433        /// 1434        #[weight = <T as Config>::WeightInfo::enable_contract_sponsoring()]1435        pub fn enable_contract_sponsoring(1436            origin,1437            contract_address: T::AccountId,1438            enable: bool1439        ) -> DispatchResult {14401441            let sender = ensure_signed(origin)?;14421443            #[cfg(feature = "runtime-benchmarks")]1444            <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());14451446            Self::ensure_contract_owned(sender, &contract_address)?;14471448            <ContractSelfSponsoring<T>>::insert(contract_address, enable);1449            Ok(())1450        }14511452        /// Set the rate limit for contract sponsoring to specified number of blocks.1453        /// 1454        /// If not set (has the default value of 0 blocks), the sponsoring will be disabled. 1455        /// If set to the number B (for blocks), the transactions will be sponsored with a rate 1456        /// limit of B, i.e. fees for every transaction sent to this smart contract will be paid 1457        /// from contract endowment if there are at least B blocks between such transactions. 1458        /// Nonetheless, if transactions are sent more frequently, the fees are paid by the sender.1459        /// 1460        /// # Permissions1461        /// 1462        /// * Contract Owner1463        /// 1464        /// # Arguments1465        /// 1466        /// -`contract_address`: Address of the contract to sponsor1467        /// -`rate_limit`: Number of blocks to wait until the next sponsored transaction is allowed1468        /// 1469        #[weight = <T as Config>::WeightInfo::set_contract_sponsoring_rate_limit()]1470        pub fn set_contract_sponsoring_rate_limit(1471            origin,1472            contract_address: T::AccountId,1473            rate_limit: T::BlockNumber1474        ) -> DispatchResult {1475            let sender = ensure_signed(origin)?;14761477            #[cfg(feature = "runtime-benchmarks")]1478            <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());14791480            Self::ensure_contract_owned(sender, &contract_address)?;1481            <ContractSponsoringRateLimit<T>>::insert(contract_address, rate_limit);1482            Ok(())1483        }14841485        /// Enable the white list for a contract. Only addresses added to the white list with addToContractWhiteList will be able to call this smart contract.1486        /// 1487        /// # Permissions1488        /// 1489        /// * Address that deployed smart contract.1490        /// 1491        /// # Arguments1492        /// 1493        /// -`contract_address`: Address of the contract.1494        /// 1495        /// - `enable`: .  1496        #[weight = <T as Config>::WeightInfo::toggle_contract_white_list()]1497        pub fn toggle_contract_white_list(1498            origin,1499            contract_address: T::AccountId,1500            enable: bool1501        ) -> DispatchResult {1502            let sender = ensure_signed(origin)?;15031504            #[cfg(feature = "runtime-benchmarks")]1505            <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());15061507            Self::ensure_contract_owned(sender, &contract_address)?;1508            <ContractWhiteListEnabled<T>>::insert(contract_address, enable);1509            Ok(())1510        }1511        1512        /// Add an address to smart contract white list.1513        /// 1514        /// # Permissions1515        /// 1516        /// * Address that deployed smart contract.1517        /// 1518        /// # Arguments1519        /// 1520        /// -`contract_address`: Address of the contract.1521        ///1522        /// -`account_address`: Address to add.1523        #[weight = <T as Config>::WeightInfo::add_to_contract_white_list()]1524        pub fn add_to_contract_white_list(1525            origin,1526            contract_address: T::AccountId,1527            account_address: T::AccountId1528        ) -> DispatchResult {1529            let sender = ensure_signed(origin)?;15301531            #[cfg(feature = "runtime-benchmarks")]1532            <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());1533            1534            Self::ensure_contract_owned(sender, &contract_address)?;      1535            <ContractWhiteList<T>>::insert(contract_address, account_address, true);1536            Ok(())1537        }15381539        /// Remove an address from smart contract white list.1540        /// 1541        /// # Permissions1542        /// 1543        /// * Address that deployed smart contract.1544        /// 1545        /// # Arguments1546        /// 1547        /// -`contract_address`: Address of the contract.1548        ///1549        /// -`account_address`: Address to remove.1550        #[weight = <T as Config>::WeightInfo::remove_from_contract_white_list()]1551        pub fn remove_from_contract_white_list(1552            origin,1553            contract_address: T::AccountId,1554            account_address: T::AccountId1555        ) -> DispatchResult {1556            let sender = ensure_signed(origin)?;15571558            #[cfg(feature = "runtime-benchmarks")]1559            <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());15601561            Self::ensure_contract_owned(sender, &contract_address)?;1562            <ContractWhiteList<T>>::remove(contract_address, account_address);1563            Ok(())1564        }15651566        #[weight = <T as Config>::WeightInfo::set_collection_limits()]1567        pub fn set_collection_limits(1568            origin,1569            collection_id: u32,1570            new_limits: CollectionLimits,1571        ) -> DispatchResult {1572            let sender = ensure_signed(origin)?;1573            Self::check_owner_permissions(collection_id, sender.clone())?;1574            let mut target_collection = <Collection<T>>::get(collection_id);1575            let old_limits = target_collection.limits;1576            let chain_limits = ChainLimit::get();15771578            // collection bounds1579            ensure!(new_limits.sponsor_transfer_timeout <= MAX_SPONSOR_TIMEOUT &&1580                new_limits.account_token_ownership_limit <= MAX_TOKEN_OWNERSHIP && 1581                new_limits.sponsored_data_size <= chain_limits.custom_data_limit,1582                Error::<T>::CollectionLimitBoundsExceeded);15831584            // token_limit   check  prev1585            ensure!(old_limits.token_limit >= new_limits.token_limit, Error::<T>::CollectionTokenLimitExceeded);1586            ensure!(new_limits.token_limit > 0, Error::<T>::CollectionTokenLimitExceeded);15871588            ensure!(1589                (old_limits.owner_can_transfer || !new_limits.owner_can_transfer) &&1590                (old_limits.owner_can_destroy || !new_limits.owner_can_destroy),1591                Error::<T>::OwnerPermissionsCantBeReverted,1592            );15931594            target_collection.limits = new_limits;1595            <Collection<T>>::insert(collection_id, target_collection);15961597            Ok(())1598        } 1599    }1600}16011602impl<T: Config> Module<T> {16031604    pub fn transfer_internal(sender: T::AccountId, recipient: T::AccountId, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {16051606        let target_collection = <Collection<T>>::get(collection_id);16071608        // Limits check1609        Self::is_correct_transfer(collection_id, &target_collection, &recipient)?;16101611        // Transfer permissions check1612        ensure!(Self::is_item_owner(sender.clone(), collection_id, item_id) ||1613            Self::is_owner_or_admin_permissions(collection_id, sender.clone()),1614            Error::<T>::NoPermission);16151616        if target_collection.access == AccessMode::WhiteList {1617            Self::check_white_list(collection_id, &sender)?;1618            Self::check_white_list(collection_id, &recipient)?;1619        }16201621        match target_collection.mode1622        {1623            CollectionMode::NFT => Self::transfer_nft(collection_id, item_id, sender.clone(), recipient.clone())?,1624            CollectionMode::Fungible(_)  => Self::transfer_fungible(collection_id, value, &sender, &recipient)?,1625            CollectionMode::ReFungible  => Self::transfer_refungible(collection_id, item_id, value, sender.clone(), recipient.clone())?,1626            _ => ()1627        };16281629        Self::deposit_event(RawEvent::Transfer(collection_id, item_id, sender, recipient, value));16301631        Ok(())1632    }163316341635    fn is_correct_transfer(collection_id: CollectionId, collection: &CollectionType<T::AccountId>, recipient: &T::AccountId) -> DispatchResult {16361637        // check token limit and account token limit1638        let account_items: u32 = <AddressTokens<T>>::get(collection_id, recipient).len() as u32;1639        ensure!(collection.limits.account_token_ownership_limit > account_items,  Error::<T>::AccountTokenLimitExceeded);1640        1641        Ok(())1642    }16431644    fn can_create_items_in_collection(collection_id: CollectionId, collection: &CollectionType<T::AccountId>, sender: &T::AccountId, owner: &T::AccountId) -> DispatchResult {16451646        // check token limit and account token limit1647        let total_items: u32 = ItemListIndex::get(collection_id);1648        let account_items: u32 = <AddressTokens<T>>::get(collection_id, owner).len() as u32;1649        ensure!(collection.limits.token_limit > total_items,  Error::<T>::CollectionTokenLimitExceeded);1650        ensure!(collection.limits.account_token_ownership_limit > account_items,  Error::<T>::AccountTokenLimitExceeded);16511652        if !Self::is_owner_or_admin_permissions(collection_id, sender.clone()) {1653            ensure!(collection.mint_mode == true, Error::<T>::PublicMintingNotAllowed);1654            Self::check_white_list(collection_id, owner)?;1655            Self::check_white_list(collection_id, sender)?;1656        }16571658        Ok(())1659    }16601661    fn validate_create_item_args(target_collection: &CollectionType<T::AccountId>, data: &CreateItemData) -> DispatchResult {1662        match target_collection.mode1663        {1664            CollectionMode::NFT => {1665                if let CreateItemData::NFT(data) = data {1666                    // check sizes1667                    ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, Error::<T>::TokenConstDataLimitExceeded);1668                    ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);1669                } else {1670                    fail!(Error::<T>::NotNftDataUsedToMintNftCollectionToken);1671                }1672            },1673            CollectionMode::Fungible(_) => {1674                if let CreateItemData::Fungible(_) = data {1675                } else {1676                    fail!(Error::<T>::NotFungibleDataUsedToMintFungibleCollectionToken);1677                }1678            },1679            CollectionMode::ReFungible => {1680                if let CreateItemData::ReFungible(data) = data {16811682                    // check sizes1683                    ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, Error::<T>::TokenConstDataLimitExceeded);1684                    ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);16851686                    // Check refungibility limits1687                    ensure!(data.pieces <= MAX_REFUNGIBLE_PIECES, Error::<T>::WrongRefungiblePieces);1688                    ensure!(data.pieces > 0, Error::<T>::WrongRefungiblePieces);1689                } else {1690                    fail!(Error::<T>::NotReFungibleDataUsedToMintReFungibleCollectionToken);1691                }1692            },1693            _ => { fail!(Error::<T>::UnexpectedCollectionType); }1694        };16951696        Ok(())1697    }16981699    fn create_item_no_validation(collection_id: CollectionId, owner: T::AccountId, data: CreateItemData) -> DispatchResult {1700        match data1701        {1702            CreateItemData::NFT(data) => {1703                let item = NftItemType {1704                    owner: owner.clone(),1705                    const_data: data.const_data,1706                    variable_data: data.variable_data1707                };17081709                Self::add_nft_item(collection_id, item)?;1710            },1711            CreateItemData::Fungible(data) => {1712                Self::add_fungible_item(collection_id, &owner, data.value)?;1713            },1714            CreateItemData::ReFungible(data) => {1715                let mut owner_list = Vec::new();1716                owner_list.push(Ownership {owner: owner.clone(), fraction: data.pieces});17171718                let item = ReFungibleItemType {1719                    owner: owner_list,1720                    const_data: data.const_data,1721                    variable_data: data.variable_data1722                };17231724                Self::add_refungible_item(collection_id, item)?;1725            }1726        };17271728        // call event1729        Self::deposit_event(RawEvent::ItemCreated(collection_id, <ItemListIndex>::get(collection_id), owner));17301731        Ok(())1732    }17331734    fn add_fungible_item(collection_id: CollectionId, owner: &T::AccountId, value: u128) -> DispatchResult {17351736        // Does new owner already have an account?1737        let mut balance: u128 = 0;1738        if <FungibleItemList<T>>::contains_key(collection_id, owner) {1739            balance = <FungibleItemList<T>>::get(collection_id, owner).value;1740        } 17411742        // Mint 1743        let item = FungibleItemType {1744            value: balance + value1745        };1746        <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), item);17471748        // Update balance1749        let new_balance = <Balance<T>>::get(collection_id, owner)1750            .checked_add(value)1751            .ok_or(Error::<T>::NumOverflow)?;1752        <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);17531754        Ok(())1755    }17561757    fn add_refungible_item(collection_id: CollectionId, item: ReFungibleItemType<T::AccountId>) -> DispatchResult {1758        let current_index = <ItemListIndex>::get(collection_id)1759            .checked_add(1)1760            .ok_or(Error::<T>::NumOverflow)?;1761        let itemcopy = item.clone();17621763        let value = item.owner.first().unwrap().fraction;1764        let owner = item.owner.first().unwrap().owner.clone();17651766        Self::add_token_index(collection_id, current_index, &owner)?;17671768        <ItemListIndex>::insert(collection_id, current_index);1769        <ReFungibleItemList<T>>::insert(collection_id, current_index, itemcopy);17701771        // Update balance1772        let new_balance = <Balance<T>>::get(collection_id, &owner)1773            .checked_add(value)1774            .ok_or(Error::<T>::NumOverflow)?;1775        <Balance<T>>::insert(collection_id, owner.clone(), new_balance);17761777        Ok(())1778    }17791780    fn add_nft_item(collection_id: CollectionId, item: NftItemType<T::AccountId>) -> DispatchResult {1781        let current_index = <ItemListIndex>::get(collection_id)1782            .checked_add(1)1783            .ok_or(Error::<T>::NumOverflow)?;17841785        let item_owner = item.owner.clone();1786        Self::add_token_index(collection_id, current_index, &item.owner)?;17871788        <ItemListIndex>::insert(collection_id, current_index);1789        <NftItemList<T>>::insert(collection_id, current_index, item);17901791        // Update balance1792        let new_balance = <Balance<T>>::get(collection_id, item_owner.clone())1793            .checked_add(1)1794            .ok_or(Error::<T>::NumOverflow)?;1795        <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);17961797        Ok(())1798    }17991800    fn burn_refungible_item(1801        collection_id: CollectionId,1802        item_id: TokenId,1803        owner: &T::AccountId,1804    ) -> DispatchResult {1805        ensure!(1806            <ReFungibleItemList<T>>::contains_key(collection_id, item_id),1807            Error::<T>::TokenNotFound1808        );1809        let mut token = <ReFungibleItemList<T>>::get(collection_id, item_id);1810        let rft_balance = token1811            .owner1812            .iter()1813            .filter(|&i| i.owner == *owner)1814            .next()1815            .unwrap();1816        Self::remove_token_index(collection_id, item_id, owner)?;18171818        // update balance1819        let new_balance = <Balance<T>>::get(collection_id, rft_balance.owner.clone())1820            .checked_sub(rft_balance.fraction)1821            .ok_or(Error::<T>::NumOverflow)?;1822        <Balance<T>>::insert(collection_id, rft_balance.owner.clone(), new_balance);18231824        // Re-create owners list with sender removed1825        let index = token1826            .owner1827            .iter()1828            .position(|i| i.owner == *owner)1829            .unwrap();1830        token.owner.remove(index);1831        let owner_count = token.owner.len();18321833        // Burn the token completely if this was the last (only) owner1834        if owner_count == 0 {1835            <ReFungibleItemList<T>>::remove(collection_id, item_id);1836        }1837        else {1838            <ReFungibleItemList<T>>::insert(collection_id, item_id, token);1839        }18401841        Ok(())1842    }18431844    fn burn_nft_item(collection_id: CollectionId, item_id: TokenId) -> DispatchResult {1845        ensure!(1846            <NftItemList<T>>::contains_key(collection_id, item_id),1847            Error::<T>::TokenNotFound1848        );1849        let item = <NftItemList<T>>::get(collection_id, item_id);1850        Self::remove_token_index(collection_id, item_id, &item.owner)?;18511852        // update balance1853        let new_balance = <Balance<T>>::get(collection_id, &item.owner)1854            .checked_sub(1)1855            .ok_or(Error::<T>::NumOverflow)?;1856        <Balance<T>>::insert(collection_id, item.owner.clone(), new_balance);1857        <NftItemList<T>>::remove(collection_id, item_id);18581859        Ok(())1860    }18611862    fn burn_fungible_item(owner: &T::AccountId, collection_id: CollectionId, value: u128) -> DispatchResult {1863        ensure!(1864            <FungibleItemList<T>>::contains_key(collection_id, owner),1865            Error::<T>::TokenNotFound1866        );1867        let mut balance = <FungibleItemList<T>>::get(collection_id, owner);1868        ensure!(balance.value >= value, Error::<T>::TokenValueNotEnough);18691870        // update balance1871        let new_balance = <Balance<T>>::get(collection_id, owner)1872            .checked_sub(value)1873            .ok_or(Error::<T>::NumOverflow)?;1874        <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);18751876        if balance.value - value > 0 {1877            balance.value -= value;1878            <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), balance);1879        }1880        else {1881            <FungibleItemList<T>>::remove(collection_id, owner);1882        }18831884        Ok(())1885    }18861887    fn collection_exists(collection_id: CollectionId) -> DispatchResult {1888        ensure!(1889            <Collection<T>>::contains_key(collection_id),1890            Error::<T>::CollectionNotFound1891        );1892        Ok(())1893    }18941895    fn check_owner_permissions(collection_id: CollectionId, subject: T::AccountId) -> DispatchResult {1896        Self::collection_exists(collection_id)?;18971898        let target_collection = <Collection<T>>::get(collection_id);1899        ensure!(1900            subject == target_collection.owner,1901            Error::<T>::NoPermission1902        );19031904        Ok(())1905    }19061907    fn is_owner_or_admin_permissions(collection_id: CollectionId, subject: T::AccountId) -> bool {1908        let target_collection = <Collection<T>>::get(collection_id);1909        let mut result: bool = subject == target_collection.owner;1910        let exists = <AdminList<T>>::contains_key(collection_id);19111912        if !result & exists {1913            if <AdminList<T>>::get(collection_id).contains(&subject) {1914                result = true1915            }1916        }19171918        result1919    }19201921    fn check_owner_or_admin_permissions(1922        collection_id: CollectionId,1923        subject: T::AccountId,1924    ) -> DispatchResult {1925        Self::collection_exists(collection_id)?;1926        let result = Self::is_owner_or_admin_permissions(collection_id, subject.clone());19271928        ensure!(1929            result,1930            Error::<T>::NoPermission1931        );1932        Ok(())1933    }19341935    fn owned_amount(1936        subject: T::AccountId,1937        collection_id: CollectionId,1938        item_id: TokenId,1939    ) -> Option<u128> {1940        let target_collection = <Collection<T>>::get(collection_id);19411942        match target_collection.mode {1943            CollectionMode::NFT => {1944                if <NftItemList<T>>::get(collection_id, item_id).owner == subject {1945                    return Some(1)1946                }1947                None1948            },1949            CollectionMode::Fungible(_) => {1950                if <FungibleItemList<T>>::contains_key(collection_id, &subject) {1951                    return Some(<FungibleItemList<T>>::get(collection_id, &subject)1952                        .value);1953                }1954                None1955            },1956            CollectionMode::ReFungible => <ReFungibleItemList<T>>::get(collection_id, item_id)1957                .owner1958                .iter()1959                .find(|i| i.owner == subject)1960                .map(|i| i.fraction),1961            CollectionMode::Invalid => None,1962        }1963    }19641965    fn is_item_owner(subject: T::AccountId, collection_id: CollectionId, item_id: TokenId) -> bool {1966        let target_collection = <Collection<T>>::get(collection_id);19671968        match target_collection.mode {1969            CollectionMode::NFT => {1970                <NftItemList<T>>::get(collection_id, item_id).owner == subject1971            }1972            CollectionMode::Fungible(_) => {1973                <FungibleItemList<T>>::contains_key(collection_id, &subject)1974            }1975            CollectionMode::ReFungible => {1976                <ReFungibleItemList<T>>::get(collection_id, item_id)1977                    .owner1978                    .iter()1979                    .any(|i| i.owner == subject)1980            }1981            CollectionMode::Invalid => false,1982        }1983    }19841985    fn check_white_list(collection_id: CollectionId, address: &T::AccountId) -> DispatchResult {1986        let mes = Error::<T>::AddresNotInWhiteList;1987        ensure!(<WhiteList<T>>::contains_key(collection_id, address), mes);19881989        Ok(())1990    }19911992    /// Check if token exists. In case of Fungible, check if there is an entry for 1993    /// the owner in fungible balances double map1994    fn token_exists(1995        collection_id: CollectionId,1996        item_id: TokenId,1997        owner: &T::AccountId1998    ) -> DispatchResult {1999        let target_collection = <Collection<T>>::get(collection_id);2000        let exists = match target_collection.mode2001        {2002            CollectionMode::NFT => <NftItemList<T>>::contains_key(collection_id, item_id),2003            CollectionMode::Fungible(_)  => <FungibleItemList<T>>::contains_key(collection_id, owner),2004            CollectionMode::ReFungible  => <ReFungibleItemList<T>>::contains_key(collection_id, item_id),2005            _ => false2006        };20072008        ensure!(exists == true, Error::<T>::TokenNotFound);2009        Ok(())2010    }20112012    fn transfer_fungible(2013        collection_id: CollectionId,2014        value: u128,2015        owner: &T::AccountId,2016        recipient: &T::AccountId,2017    ) -> DispatchResult {2018        Self::token_exists(collection_id, 0, owner)?;20192020        let mut balance = <FungibleItemList<T>>::get(collection_id, owner);2021        ensure!(balance.value >= value, Error::<T>::TokenValueTooLow);20222023        // Send balance to recipient (updates balanceOf of recipient)2024        Self::add_fungible_item(collection_id, recipient, value)?;20252026        // update balanceOf of sender2027        <Balance<T>>::insert(collection_id, (*owner).clone(), balance.value - value);20282029        // Reduce or remove sender2030        if balance.value == value {2031            <FungibleItemList<T>>::remove(collection_id, owner);2032        }2033        else {2034            balance.value -= value;2035            <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), balance);2036        }20372038        Ok(())2039    }20402041    fn transfer_refungible(2042        collection_id: CollectionId,2043        item_id: TokenId,2044        value: u128,2045        owner: T::AccountId,2046        new_owner: T::AccountId,2047    ) -> DispatchResult {2048        Self::token_exists(collection_id, item_id, &owner)?;20492050        let full_item = <ReFungibleItemList<T>>::get(collection_id, item_id);2051        let item = full_item2052            .owner2053            .iter()2054            .filter(|i| i.owner == owner)2055            .next()2056            .ok_or(Error::<T>::NumOverflow)?;2057        let amount = item.fraction;20582059        ensure!(amount >= value, Error::<T>::TokenValueTooLow);20602061        // update balance2062        let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())2063            .checked_sub(value)2064            .ok_or(Error::<T>::NumOverflow)?;2065        <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);20662067        let balancenew_owner = <Balance<T>>::get(collection_id, new_owner.clone())2068            .checked_add(value)2069            .ok_or(Error::<T>::NumOverflow)?;2070        <Balance<T>>::insert(collection_id, new_owner.clone(), balancenew_owner);20712072        let old_owner = item.owner.clone();2073        let new_owner_has_account = full_item.owner.iter().any(|i| i.owner == new_owner);20742075        // transfer2076        if amount == value && !new_owner_has_account {2077            // change owner2078            // new owner do not have account2079            let mut new_full_item = full_item.clone();2080            new_full_item2081                .owner2082                .iter_mut()2083                .find(|i| i.owner == owner)2084                .unwrap()2085                .owner = new_owner.clone();2086            <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);20872088            // update index collection2089            Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;2090        } else {2091            let mut new_full_item = full_item.clone();2092            new_full_item2093                .owner2094                .iter_mut()2095                .find(|i| i.owner == owner)2096                .unwrap()2097                .fraction -= value;20982099            // separate amount2100            if new_owner_has_account {2101                // new owner has account2102                new_full_item2103                    .owner2104                    .iter_mut()2105                    .find(|i| i.owner == new_owner)2106                    .unwrap()2107                    .fraction += value;2108            } else {2109                // new owner do not have account2110                new_full_item.owner.push(Ownership {2111                    owner: new_owner.clone(),2112                    fraction: value,2113                });2114                Self::add_token_index(collection_id, item_id, &new_owner)?;2115            }21162117            <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);2118        }21192120        Ok(())2121    }21222123    fn transfer_nft(2124        collection_id: CollectionId,2125        item_id: TokenId,2126        sender: T::AccountId,2127        new_owner: T::AccountId,2128    ) -> DispatchResult {2129        Self::token_exists(collection_id, item_id, &sender)?;21302131        let mut item = <NftItemList<T>>::get(collection_id, item_id);21322133        ensure!(2134            sender == item.owner,2135            Error::<T>::MustBeTokenOwner2136        );21372138        // update balance2139        let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())2140            .checked_sub(1)2141            .ok_or(Error::<T>::NumOverflow)?;2142        <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);21432144        let balancenew_owner = <Balance<T>>::get(collection_id, new_owner.clone())2145            .checked_add(1)2146            .ok_or(Error::<T>::NumOverflow)?;2147        <Balance<T>>::insert(collection_id, new_owner.clone(), balancenew_owner);21482149        // change owner2150        let old_owner = item.owner.clone();2151        item.owner = new_owner.clone();2152        <NftItemList<T>>::insert(collection_id, item_id, item);21532154        // update index collection2155        Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;21562157        Ok(())2158    }2159    2160    fn set_re_fungible_variable_data(2161        collection_id: CollectionId,2162        item_id: TokenId,2163        data: Vec<u8>2164    ) -> DispatchResult {2165        let mut item = <ReFungibleItemList<T>>::get(collection_id, item_id);21662167        item.variable_data = data;21682169        <ReFungibleItemList<T>>::insert(collection_id, item_id, item);21702171        Ok(())2172    }21732174    fn set_nft_variable_data(2175        collection_id: CollectionId,2176        item_id: TokenId,2177        data: Vec<u8>2178    ) -> DispatchResult {2179        let mut item = <NftItemList<T>>::get(collection_id, item_id);2180        2181        item.variable_data = data;21822183        <NftItemList<T>>::insert(collection_id, item_id, item);2184        2185        Ok(())2186    }21872188    fn init_collection(item: &CollectionType<T::AccountId>) {2189        // check params2190        assert!(2191            item.decimal_points <= MAX_DECIMAL_POINTS,2192            "decimal_points parameter must be lower than MAX_DECIMAL_POINTS"2193        );2194        assert!(2195            item.name.len() <= 64,2196            "Collection name can not be longer than 63 char"2197        );2198        assert!(2199            item.name.len() <= 256,2200            "Collection description can not be longer than 255 char"2201        );2202        assert!(2203            item.token_prefix.len() <= 16,2204            "Token prefix can not be longer than 15 char"2205        );22062207        // Generate next collection ID2208        let next_id = CreatedCollectionCount::get()2209            .checked_add(1)2210            .unwrap();22112212        CreatedCollectionCount::put(next_id);2213    }22142215    fn init_nft_token(collection_id: CollectionId, item: &NftItemType<T::AccountId>) {2216        let current_index = <ItemListIndex>::get(collection_id)2217            .checked_add(1)2218            .unwrap();22192220        let item_owner = item.owner.clone();2221        Self::add_token_index(collection_id, current_index, &item.owner).unwrap();22222223        <ItemListIndex>::insert(collection_id, current_index);22242225        // Update balance2226        let new_balance = <Balance<T>>::get(collection_id, &item_owner)2227            .checked_add(1)2228            .unwrap();2229        <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);2230    }22312232    fn init_fungible_token(collection_id: CollectionId, owner: &T::AccountId, item: &FungibleItemType) {2233        let current_index = <ItemListIndex>::get(collection_id)2234            .checked_add(1)2235            .unwrap();22362237        Self::add_token_index(collection_id, current_index, owner).unwrap();22382239        <ItemListIndex>::insert(collection_id, current_index);22402241        // Update balance2242        let new_balance = <Balance<T>>::get(collection_id, owner)2243            .checked_add(item.value)2244            .unwrap();2245        <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);2246    }22472248    fn init_refungible_token(collection_id: CollectionId, item: &ReFungibleItemType<T::AccountId>) {2249        let current_index = <ItemListIndex>::get(collection_id)2250            .checked_add(1)2251            .unwrap();22522253        let value = item.owner.first().unwrap().fraction;2254        let owner = item.owner.first().unwrap().owner.clone();22552256        Self::add_token_index(collection_id, current_index, &owner).unwrap();22572258        <ItemListIndex>::insert(collection_id, current_index);22592260        // Update balance2261        let new_balance = <Balance<T>>::get(collection_id, &owner)2262            .checked_add(value)2263            .unwrap();2264        <Balance<T>>::insert(collection_id, owner.clone(), new_balance);2265    }22662267    fn add_token_index(collection_id: CollectionId, item_index: TokenId, owner: &T::AccountId) -> DispatchResult {22682269        // add to account limit2270        if <AccountItemCount<T>>::contains_key(owner) {22712272            // bound Owned tokens by a single address2273            let count = <AccountItemCount<T>>::get(owner);2274            ensure!(count < ChainLimit::get().account_token_ownership_limit, Error::<T>::AddressOwnershipLimitExceeded);22752276            <AccountItemCount<T>>::insert(owner.clone(), count2277                .checked_add(1)2278                .ok_or(Error::<T>::NumOverflow)?);2279        }2280        else {2281            <AccountItemCount<T>>::insert(owner.clone(), 1);2282        }22832284        let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner);2285        if list_exists {2286            let mut list = <AddressTokens<T>>::get(collection_id, owner);2287            let item_contains = list.contains(&item_index.clone());22882289            if !item_contains {2290                list.push(item_index.clone());2291            }22922293            <AddressTokens<T>>::insert(collection_id, owner.clone(), list);2294        } else {2295            let mut itm = Vec::new();2296            itm.push(item_index.clone());2297            <AddressTokens<T>>::insert(collection_id, owner.clone(), itm);2298        }22992300        Ok(())2301    }23022303    fn remove_token_index(2304        collection_id: CollectionId,2305        item_index: TokenId,2306        owner: &T::AccountId,2307    ) -> DispatchResult {23082309        // update counter2310        <AccountItemCount<T>>::insert(owner.clone(), 2311            <AccountItemCount<T>>::get(owner)2312            .checked_sub(1)2313            .ok_or(Error::<T>::NumOverflow)?);231423152316        let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner);2317        if list_exists {2318            let mut list = <AddressTokens<T>>::get(collection_id, owner);2319            let item_contains = list.contains(&item_index.clone());23202321            if item_contains {2322                list.retain(|&item| item != item_index);2323                <AddressTokens<T>>::insert(collection_id, owner.clone(), list);2324            }2325        }23262327        Ok(())2328    }23292330    fn move_token_index(2331        collection_id: CollectionId,2332        item_index: TokenId,2333        old_owner: &T::AccountId,2334        new_owner: &T::AccountId,2335    ) -> DispatchResult {2336        Self::remove_token_index(collection_id, item_index, old_owner)?;2337        Self::add_token_index(collection_id, item_index, new_owner)?;23382339        Ok(())2340    }2341    2342    fn ensure_contract_owned(account: T::AccountId, contract: &T::AccountId) -> DispatchResult {2343        if <ContractOwner<T>>::contains_key(contract.clone()) {2344            let owner = <ContractOwner<T>>::get(contract);2345            ensure!(account == owner, Error::<T>::NoPermission);2346        } else {2347            fail!(Error::<T>::NoPermission);2348        }23492350        Ok(())2351    }2352}23532354////////////////////////////////////////////////////////////////////////////////////////////////////2355// Economic models2356// #region23572358/// Fee multiplier.2359pub type Multiplier = FixedU128;23602361type BalanceOf<T> = <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::Balance;23622363/// Require the transactor pay for themselves and maybe include a tip to gain additional priority2364/// in the queue.2365#[derive(Encode, Decode, Clone, Eq, PartialEq)]2366pub struct ChargeTransactionPayment<T: Config>(#[codec(compact)] BalanceOf<T>);23672368impl<T: Config + Send + Sync> sp_std::fmt::Debug 2369    for ChargeTransactionPayment<T>2370{2371	#[cfg(feature = "std")]2372	fn fmt(&self, f: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {2373		write!(f, "ChargeTransactionPayment<{:?}>", self.0)2374	}2375	#[cfg(not(feature = "std"))]2376	fn fmt(&self, _: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {2377		Ok(())2378	}2379}23802381impl<T: Config> ChargeTransactionPayment<T>2382where2383    T::Call: Dispatchable<Info=DispatchInfo, PostInfo=PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,2384    BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,2385    T::AccountId: AsRef<[u8]>,2386    T::AccountId: UncheckedFrom<T::Hash>,2387{2388    fn traditional_fee(2389        len: usize,2390        info: &DispatchInfoOf<T::Call>,2391        tip: BalanceOf<T>,2392    ) -> BalanceOf<T>2393    where2394        T::Call: Dispatchable<Info = DispatchInfo>,2395    {2396        <pallet_transaction_payment::Module<T>>::compute_fee(len as u32, info, tip)2397    }23982399	fn get_priority(len: usize, info: &DispatchInfoOf<T::Call>, final_fee: BalanceOf<T>) -> TransactionPriority {2400        let weight_saturation = T::BlockWeights::get().max_block / info.weight.max(1);2401        let max_block_length = *T::BlockLength::get().max.get(DispatchClass::Normal);2402        let len_saturation = max_block_length as u64 / (len as u64).max(1);2403        let coefficient: BalanceOf<T> = weight_saturation2404            .min(len_saturation)2405            .saturated_into::<BalanceOf<T>>();2406        final_fee2407            .saturating_mul(coefficient)2408            .saturated_into::<TransactionPriority>()2409    }24102411    fn withdraw_fee(2412        &self,2413        who: &T::AccountId,2414        call: &T::Call,2415        info: &DispatchInfoOf<T::Call>,2416        len: usize,2417	) -> Result<2418		(2419			BalanceOf<T>,2420			<<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::LiquidityInfo,2421		),2422		TransactionValidityError,2423	> {2424        let tip = self.0;24252426        // Set fee based on call type. Creating collection costs 1 Unique.2427        // All other transactions have traditional fees so far2428        // let fee = match call.is_sub_type() {2429        //     Some(Call::create_collection(..)) => <BalanceOf<T>>::from(1_000_000_000),2430        //     _ => Self::traditional_fee(len, info, tip), // Flat fee model, use only for testing purposes2431        //                                                 // _ => <BalanceOf<T>>::from(100)2432        // };2433        let fee = Self::traditional_fee(len, info, tip);24342435        // Only mess with balances if fee is not zero.2436        if fee.is_zero() {2437            return <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::withdraw_fee(who, call, info, fee, tip)2438			.map(|i| (fee, i));2439        }24402441        // Determine who is paying transaction fee based on ecnomic model2442        // Parse call to extract collection ID and access collection sponsor2443        let mut sponsor: T::AccountId = match IsSubType::<Call<T>>::is_sub_type(call) {2444            Some(Call::create_item(collection_id, _owner, _properties)) => {24452446                // sponsor timeout2447                let block_number = <system::Module<T>>::block_number() as T::BlockNumber;24482449                let limit = <Collection<T>>::get(collection_id).limits.sponsor_transfer_timeout;2450                let mut sponsored = true;2451                if <CreateItemBasket<T>>::contains_key((collection_id, &who)) {2452                    let last_tx_block = <CreateItemBasket<T>>::get((collection_id, &who));2453                    let limit_time = last_tx_block + limit.into();2454                    if block_number <= limit_time {2455                        sponsored = false;2456                    }2457                }2458                if sponsored {2459                    <CreateItemBasket<T>>::insert((collection_id, who.clone()), block_number);2460                }24612462                // check free create limit2463                if (<Collection<T>>::get(collection_id).limits.sponsored_data_size >= (_properties.len() as u32)) &&2464                   (<Collection<T>>::get(collection_id).sponsor_confirmed) &&2465                   (sponsored)2466                {2467                    <Collection<T>>::get(collection_id).sponsor2468                } else {2469                    T::AccountId::default()2470                }2471            }2472            Some(Call::transfer(_new_owner, collection_id, item_id, _value)) => {2473                2474                let mut sponsor_transfer = false;2475                if <Collection<T>>::get(collection_id).sponsor_confirmed {24762477                    let collection_limits = <Collection<T>>::get(collection_id).limits;2478                    let collection_mode = <Collection<T>>::get(collection_id).mode;2479    2480                    // sponsor timeout2481                    let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2482                    sponsor_transfer = match collection_mode {2483                        CollectionMode::NFT => {2484    2485                            // get correct limit2486                            let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2487                                collection_limits.sponsor_transfer_timeout2488                            } else {2489                                ChainLimit::get().nft_sponsor_transfer_timeout2490                            };2491    2492                            let mut sponsored = true;2493                            if <NftTransferBasket<T>>::contains_key(collection_id, item_id) {2494                                let last_tx_block = <NftTransferBasket<T>>::get(collection_id, item_id);2495                                let limit_time = last_tx_block + limit.into();2496                                if block_number <= limit_time {2497                                    sponsored = false;2498                                }2499                            }2500                            if sponsored {2501                                <NftTransferBasket<T>>::insert(collection_id, item_id, block_number);2502                            }25032504                            sponsored2505                        }2506                        CollectionMode::Fungible(_) => {2507    2508                            // get correct limit2509                            let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2510                                collection_limits.sponsor_transfer_timeout2511                            } else {2512                                ChainLimit::get().fungible_sponsor_transfer_timeout2513                            };2514    2515                            let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2516                            let mut sponsored = true;2517                            if <FungibleTransferBasket<T>>::contains_key(collection_id, who) {2518                                let last_tx_block = <FungibleTransferBasket<T>>::get(collection_id, who);2519                                let limit_time = last_tx_block + limit.into();2520                                if block_number <= limit_time {2521                                    sponsored = false;2522                                }2523                            }2524                            if sponsored {2525                                <FungibleTransferBasket<T>>::insert(collection_id, who, block_number);2526                            }25272528                            sponsored2529                        }2530                        CollectionMode::ReFungible => {2531    2532                            // get correct limit2533                            let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2534                                collection_limits.sponsor_transfer_timeout2535                            } else {2536                                ChainLimit::get().refungible_sponsor_transfer_timeout2537                            };2538    2539                            let mut sponsored = true;2540                            if <ReFungibleTransferBasket<T>>::contains_key(collection_id, item_id) {2541                                let last_tx_block = <ReFungibleTransferBasket<T>>::get(collection_id, item_id);2542                                let limit_time = last_tx_block + limit.into();2543                                if block_number <= limit_time {2544                                    sponsored = false;2545                                }2546                            }2547                            if sponsored {2548                                <ReFungibleTransferBasket<T>>::insert(collection_id, item_id, block_number);2549                            }25502551                            sponsored2552                        }2553                        _ => {2554                            false2555                        },2556                    };2557                }25582559                if !sponsor_transfer {2560                    T::AccountId::default()2561                } else {2562                    <Collection<T>>::get(collection_id).sponsor2563                }2564            }25652566            _ => T::AccountId::default(),2567        };25682569        // Sponsor smart contracts2570        sponsor = match IsSubType::<pallet_contracts::Call<T>>::is_sub_type(call) {25712572            // On instantiation: set the contract owner2573            Some(pallet_contracts::Call::instantiate(_endowment, _gas_limit, code_hash, _data, salt)) => {25742575                let new_contract_address = <pallet_contracts::Module<T>>::contract_address(2576                    &who,2577                    code_hash,2578                    salt,2579                );2580                <ContractOwner<T>>::insert(new_contract_address.clone(), who.clone());25812582                T::AccountId::default()2583            },25842585            // On instantiation with code: set the contract owner2586            Some(pallet_contracts::Call::instantiate_with_code(_endowment, _gas_limit, _code, _data, _salt))  => {25872588                let new_contract_address = <pallet_contracts::Module<T>>::contract_address(2589                    &who,2590                    &T::Hashing::hash(&_code),2591                    _salt,2592                );25932594                <ContractOwner<T>>::insert(new_contract_address.clone(), who.clone());25952596                T::AccountId::default()2597            }25982599            // When the contract is called, check if the sponsoring is enabled and pay fees from contract endowment if it is2600            Some(pallet_contracts::Call::call(dest, _value, _gas_limit, _data)) => {26012602                let called_contract: T::AccountId = T::Lookup::lookup((*dest).clone()).unwrap_or(T::AccountId::default());26032604                let owned_contract = <ContractOwner<T>>::contains_key(called_contract.clone())2605                  && <ContractOwner<T>>::get(called_contract.clone()) == *who;2606                let white_list_enabled = <ContractWhiteListEnabled<T>>::contains_key(called_contract.clone()) && <ContractWhiteListEnabled<T>>::get(called_contract.clone());2607                  2608                if !owned_contract && white_list_enabled {2609                    if !<ContractWhiteList<T>>::contains_key(called_contract.clone(), who) {2610                        return Err(InvalidTransaction::Call.into());2611                    }2612                }26132614                let mut sponsor_transfer = false;2615                if <ContractSponsoringRateLimit<T>>::contains_key(called_contract.clone()) {2616                    let last_tx_block = <ContractSponsorBasket<T>>::get((&called_contract, &who));2617                    let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2618                    let rate_limit = <ContractSponsoringRateLimit<T>>::get(&called_contract);2619                    let limit_time = last_tx_block + rate_limit;26202621                    if block_number >= limit_time {2622                        <ContractSponsorBasket<T>>::insert((called_contract.clone(), who.clone()), block_number);2623                        sponsor_transfer = true;2624                    }2625                } else {2626                    sponsor_transfer = false;2627                }2628               2629                2630                let mut sp = T::AccountId::default();2631                if sponsor_transfer {2632                    if <ContractSelfSponsoring<T>>::contains_key(called_contract.clone()) {2633                        if <ContractSelfSponsoring<T>>::get(called_contract.clone()) {2634                            sp = called_contract;2635                        }2636                    }2637                }26382639                sp2640            },26412642            _ => sponsor,2643        };26442645        let mut who_pays_fee: T::AccountId = sponsor.clone();2646        if sponsor == T::AccountId::default() {2647            who_pays_fee = who.clone();2648        }26492650		<<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::withdraw_fee(&who_pays_fee, call, info, fee, tip)2651			.map(|i| (fee, i))2652    }2653}265426552656impl<T: Config + Send + Sync> SignedExtension2657    for ChargeTransactionPayment<T>2658where2659    BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,2660    T::Call: Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,2661    T::AccountId: AsRef<[u8]>,2662    T::AccountId: UncheckedFrom<T::Hash>,2663{2664    const IDENTIFIER: &'static str = "ChargeTransactionPayment";2665    type AccountId = T::AccountId;2666    type Call = T::Call;2667    type AdditionalSigned = ();2668    type Pre = (2669        // tip2670        BalanceOf<T>,2671        // who pays fee2672        Self::AccountId,2673		// imbalance resulting from withdrawing the fee2674		<<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::LiquidityInfo,2675    );2676    fn additional_signed(&self) -> sp_std::result::Result<(), TransactionValidityError> {2677        Ok(())2678    }26792680    fn validate(2681        &self,2682        who: &Self::AccountId,2683        call: &Self::Call,2684        info: &DispatchInfoOf<Self::Call>,2685        len: usize,2686    ) -> TransactionValidity {2687		let (fee, _) = self.withdraw_fee(who, call, info, len)?;2688		Ok(ValidTransaction {2689			priority: Self::get_priority(len, info, fee),2690			..Default::default()2691		})2692    }26932694    fn pre_dispatch(2695        self,2696        who: &Self::AccountId,2697        call: &Self::Call,2698        info: &DispatchInfoOf<Self::Call>,2699        len: usize,2700    ) -> Result<Self::Pre, TransactionValidityError> {2701        let (_fee, imbalance) = self.withdraw_fee(who, call, info, len)?;2702        Ok((self.0, who.clone(), imbalance))2703    }27042705    fn post_dispatch(2706        pre: Self::Pre,2707        info: &DispatchInfoOf<Self::Call>,2708        post_info: &PostDispatchInfoOf<Self::Call>,2709        len: usize,2710        _result: &DispatchResult,2711    ) -> Result<(), TransactionValidityError> {2712		let (tip, who, imbalance) = pre;2713		let actual_fee = pallet_transaction_payment::Module::<T>::compute_actual_fee(2714			len as u32,2715			info,2716			post_info,2717			tip,2718		);2719		<T as pallet_transaction_payment::Config>::OnChargeTransaction::correct_and_deposit_fee(&who, info, post_info, actual_fee, tip, imbalance)?;2720		Ok(())2721    }2722}27232724// #endregion