git.delta.rocks / unique-network / refs/commits / 2eedf4593dca

1//2// This file is subject to the terms and conditions defined in3// file 'LICENSE', which is part of this source code package.4//56#![recursion_limit = "1024"]78#![cfg_attr(not(feature = "std"), no_std)]910#[cfg(feature = "std")]11pub use std::*;1213#[cfg(feature = "std")]14pub use serde::*;1516use codec::{Decode, Encode};17pub use frame_support::{18    construct_runtime, decl_event, decl_module, decl_storage, decl_error,19    dispatch::DispatchResult,20    ensure, fail, parameter_types,21    traits::{22        Currency, ExistenceRequirement, Get, Imbalance, KeyOwnerProofSystem, OnUnbalanced,23        Randomness, IsSubType,24    },25    weights::{26        constants::{BlockExecutionWeight, ExtrinsicBaseWeight, RocksDbWeight, WEIGHT_PER_SECOND},27        DispatchInfo, GetDispatchInfo, IdentityFee, Pays, PostDispatchInfo, Weight,28        WeightToFeePolynomial, DispatchClass,29    },30    StorageValue,31};3233use frame_system::{self as system, ensure_signed, ensure_root};34use sp_runtime::sp_std::prelude::Vec;35use sp_runtime::{36    traits::{37        Hash, DispatchInfoOf, Dispatchable, PostDispatchInfoOf, Saturating, SaturatedConversion, SignedExtension, Zero,38    },39    transaction_validity::{40        TransactionPriority, InvalidTransaction, TransactionValidity, TransactionValidityError, ValidTransaction,41    },42    FixedPointOperand, FixedU128,43};44use sp_runtime::traits::StaticLookup;45use pallet_contracts::chain_extension::UncheckedFrom;46use pallet_transaction_payment::OnChargeTransaction;4748#[cfg(test)]49mod mock;5051#[cfg(test)]52mod tests;5354mod default_weights;5556pub const MAX_DECIMAL_POINTS: DecimalPoints = 30;57pub const MAX_REFUNGIBLE_PIECES: u128 = 1_000_000_000_000_000_000_000;58pub const MAX_SPONSOR_TIMEOUT: u32 = 10_368_000;59pub const MAX_TOKEN_OWNERSHIP: u32 = 10_000_000;6061// Structs62// #region6364pub type CollectionId = u32;65pub type TokenId = u32;66pub type DecimalPoints = u8;6768#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq)]69#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]70pub enum CollectionMode {71    Invalid,72    NFT,73    // decimal points74    Fungible(DecimalPoints),75    ReFungible,76}7778impl Default for CollectionMode {79    fn default() -> Self {80        Self::Invalid81    }82}8384impl Into<u8> for CollectionMode {85    fn into(self) -> u8 {86        match self {87            CollectionMode::Invalid => 0,88            CollectionMode::NFT => 1,89            CollectionMode::Fungible(_) => 2,90            CollectionMode::ReFungible => 3,91        }92    }93}9495#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq)]96#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]97pub enum AccessMode {98    Normal,99    WhiteList,100}101impl Default for AccessMode {102    fn default() -> Self {103        Self::Normal104    }105}106107#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq)]108#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]109pub enum SchemaVersion {110    ImageURL,111    Unique,112}113impl Default for SchemaVersion {114    fn default() -> Self {115        Self::ImageURL116    }117}118119#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]120#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]121pub struct Ownership<AccountId> {122    pub owner: AccountId,123    pub fraction: u128,124}125126#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]127#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]128pub struct CollectionType<AccountId> {129    pub owner: AccountId,130    pub mode: CollectionMode,131    pub access: AccessMode,132    pub decimal_points: DecimalPoints,133    pub name: Vec<u16>,        // 64 include null escape char134    pub description: Vec<u16>, // 256 include null escape char135    pub token_prefix: Vec<u8>, // 16 include null escape char136    pub mint_mode: bool,137    pub offchain_schema: Vec<u8>,138    pub schema_version: SchemaVersion,139    pub sponsor: AccountId, // Who pays fees. If set to default address, the fees are applied to the transaction sender140    pub sponsor_confirmed: bool, // False if sponsor address has not yet confirmed sponsorship. True otherwise.141    pub limits: CollectionLimits, // Collection private restrictions 142    pub variable_on_chain_schema: Vec<u8>, //143    pub const_on_chain_schema: Vec<u8>, //144}145146#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]147#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]148pub struct NftItemType<AccountId> {149    pub owner: AccountId,150    pub const_data: Vec<u8>,151    pub variable_data: Vec<u8>,152}153154#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]155#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]156pub struct FungibleItemType {157    pub value: u128,158}159160#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]161#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]162pub struct ReFungibleItemType<AccountId> {163    pub owner: Vec<Ownership<AccountId>>,164    pub const_data: Vec<u8>,165    pub variable_data: Vec<u8>,166}167168// #[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]169// #[cfg_attr(feature = "std", derive(Serialize, Deserialize))]170// pub struct VestingItem<AccountId, Moment> {171//     pub sender: AccountId,172//     pub recipient: AccountId,173//     pub collection_id: CollectionId,174//     pub item_id: TokenId,175//     pub amount: u64,176//     pub vesting_date: Moment,177// }178179#[derive(Encode, Decode, Debug, Clone, PartialEq)]180#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]181pub struct CollectionLimits {182    pub account_token_ownership_limit: u32,183    pub sponsored_data_size: u32,184    pub token_limit: u32,185186    // Timeouts for item types in passed blocks187    pub sponsor_transfer_timeout: u32,188    pub owner_can_transfer: bool,189    pub owner_can_destroy: bool,190}191192impl Default for CollectionLimits {193    fn default() -> CollectionLimits {194        CollectionLimits { 195            account_token_ownership_limit: 10_000_000, 196            token_limit: u32::max_value(),197            sponsored_data_size: u32::MAX,198            sponsor_transfer_timeout: 14400,199            owner_can_transfer: true,200            owner_can_destroy: true201        }202    }203}204205#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]206#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]207pub struct ChainLimits {208    pub collection_numbers_limit: u32,209    pub account_token_ownership_limit: u32,210    pub collections_admins_limit: u64,211    pub custom_data_limit: u32,212213    // Timeouts for item types in passed blocks214    pub nft_sponsor_transfer_timeout: u32,215    pub fungible_sponsor_transfer_timeout: u32,216    pub refungible_sponsor_transfer_timeout: u32,217218    // Schema limits219    pub offchain_schema_limit: u32,220    pub variable_on_chain_schema_limit: u32,221    pub const_on_chain_schema_limit: u32,222}223224pub trait WeightInfo {225	fn create_collection() -> Weight;226	fn destroy_collection() -> Weight;227	fn add_to_white_list() -> Weight;228	fn remove_from_white_list() -> Weight;229    fn set_public_access_mode() -> Weight;230    fn set_mint_permission() -> Weight;231    fn change_collection_owner() -> Weight;232    fn add_collection_admin() -> Weight;233    fn remove_collection_admin() -> Weight;234    fn set_collection_sponsor() -> Weight;235    fn confirm_sponsorship() -> Weight;236    fn remove_collection_sponsor() -> Weight;237    fn create_item(s: usize) -> Weight;238    fn burn_item() -> Weight;239    fn transfer() -> Weight;240    fn approve() -> Weight;241    fn transfer_from() -> Weight;242    fn set_offchain_schema() -> Weight;243    fn set_const_on_chain_schema() -> Weight;244    fn set_variable_on_chain_schema() -> Weight;245    fn set_variable_meta_data() -> Weight;246    fn enable_contract_sponsoring() -> Weight;247    fn set_schema_version() -> Weight;248    fn set_chain_limits() -> Weight;249    fn set_contract_sponsoring_rate_limit() -> Weight;250    fn toggle_contract_white_list() -> Weight;251    fn add_to_contract_white_list() -> Weight;252    fn remove_from_contract_white_list() -> Weight;253    fn set_collection_limits() -> Weight;254}255256#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]257#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]258pub struct CreateNftData {259    pub const_data: Vec<u8>,260    pub variable_data: Vec<u8>,261}262263#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]264#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]265pub struct CreateFungibleData {266    pub value: u128,267}268269#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]270#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]271pub struct CreateReFungibleData {272    pub const_data: Vec<u8>,273    pub variable_data: Vec<u8>,274    pub pieces: u128,275}276277#[derive(Encode, Decode, Debug, Clone, PartialEq)]278#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]279pub enum CreateItemData {280    NFT(CreateNftData),281    Fungible(CreateFungibleData),282    ReFungible(CreateReFungibleData),283}284285impl CreateItemData {286    pub fn len(&self) -> usize {287        let len = match self {288            CreateItemData::NFT(data) => data.variable_data.len() + data.const_data.len(),289            CreateItemData::ReFungible(data) => data.variable_data.len() + data.const_data.len(),290            _ => 0291        };292        293        return len;294    }295}296297impl From<CreateNftData> for CreateItemData {298    fn from(item: CreateNftData) -> Self {299        CreateItemData::NFT(item)300    }301}302303impl From<CreateReFungibleData> for CreateItemData {304    fn from(item: CreateReFungibleData) -> Self {305        CreateItemData::ReFungible(item)306    }307}308309impl From<CreateFungibleData> for CreateItemData {310    fn from(item: CreateFungibleData) -> Self {311        CreateItemData::Fungible(item)312    }313}314315316decl_error! {317	/// Error for non-fungible-token module.318	pub enum Error for Module<T: Config> {319        /// Total collections bound exceeded.320        TotalCollectionsLimitExceeded,321		/// Decimal_points parameter must be lower than MAX_DECIMAL_POINTS constant, currently it is 30.322        CollectionDecimalPointLimitExceeded, 323        /// Collection name can not be longer than 63 char.324        CollectionNameLimitExceeded, 325        /// Collection description can not be longer than 255 char.326        CollectionDescriptionLimitExceeded, 327        /// Token prefix can not be longer than 15 char.328        CollectionTokenPrefixLimitExceeded,329        /// This collection does not exist.330        CollectionNotFound,331        /// Item not exists.332        TokenNotFound,333        /// Admin not found334        AdminNotFound,335        /// Arithmetic calculation overflow.336        NumOverflow,       337        /// Account already has admin role.338        AlreadyAdmin,  339        /// You do not own this collection.340        NoPermission,341        /// This address is not set as sponsor, use setCollectionSponsor first.342        ConfirmUnsetSponsorFail,343        /// Collection is not in mint mode.344        PublicMintingNotAllowed,345        /// Sender parameter and item owner must be equal.346        MustBeTokenOwner,347        /// Item balance not enough.348        TokenValueTooLow,349        /// Size of item is too large.350        NftSizeLimitExceeded,351        /// No approve found352        ApproveNotFound,353        /// Requested value more than approved.354        TokenValueNotEnough,355        /// Only approved addresses can call this method.356        ApproveRequired,357        /// Address is not in white list.358        AddresNotInWhiteList,359        /// Number of collection admins bound exceeded.360        CollectionAdminsLimitExceeded,361        /// Owned tokens by a single address bound exceeded.362        AddressOwnershipLimitExceeded,363        /// Length of items properties must be greater than 0.364        EmptyArgument,365        /// const_data exceeded data limit.366        TokenConstDataLimitExceeded,367        /// variable_data exceeded data limit.368        TokenVariableDataLimitExceeded,369        /// Not NFT item data used to mint in NFT collection.370        NotNftDataUsedToMintNftCollectionToken,371        /// Not Fungible item data used to mint in Fungible collection.372        NotFungibleDataUsedToMintFungibleCollectionToken,373        /// Not Re Fungible item data used to mint in Re Fungible collection.374        NotReFungibleDataUsedToMintReFungibleCollectionToken,375        /// Unexpected collection type.376        UnexpectedCollectionType,377        /// Can't store metadata in fungible tokens.378        CantStoreMetadataInFungibleTokens,379        /// Collection token limit exceeded380        CollectionTokenLimitExceeded,381        /// Account token limit exceeded per collection382        AccountTokenLimitExceeded,383        /// Collection limit bounds per collection exceeded384        CollectionLimitBoundsExceeded,385        /// Tried to enable permissions which are only permitted to be disabled386        OwnerPermissionsCantBeReverted,387        /// Schema data size limit bound exceeded388        SchemaDataLimitExceeded,389        /// Maximum refungibility exceeded390        WrongRefungiblePieces391	}392}393394pub trait Config: system::Config + Sized + pallet_transaction_payment::Config + pallet_contracts::Config {395    type Event: From<Event<Self>> + Into<<Self as system::Config>::Event>;396397    /// Weight information for extrinsics in this pallet.398	type WeightInfo: WeightInfo;399}400401#[cfg(feature = "runtime-benchmarks")]402mod benchmarking;403404// #endregion405406decl_storage! {407    trait Store for Module<T: Config> as Nft {408409        // Private members410        NextCollectionID: CollectionId;411        CreatedCollectionCount: u32;412        ChainVersion: u64;413        ItemListIndex: map hasher(identity) CollectionId => TokenId;414415        // Chain limits struct416        pub ChainLimit get(fn chain_limit) config(): ChainLimits;417418        // Bound counters419        CollectionCount: u32;420        pub AccountItemCount get(fn account_item_count): map hasher(twox_64_concat) T::AccountId => u32;421422        // Basic collections423        pub Collection get(fn collection) config(): map hasher(identity) CollectionId => CollectionType<T::AccountId>;424        pub AdminList get(fn admin_list_collection): map hasher(identity) CollectionId => Vec<T::AccountId>;425        pub WhiteList get(fn white_list): double_map hasher(identity) CollectionId, hasher(twox_64_concat) T::AccountId => bool;426427        /// Balance owner per collection map428        pub Balance get(fn balance_count): double_map hasher(identity) CollectionId, hasher(twox_64_concat) T::AccountId => u128;429430        /// second parameter: item id + owner account id + spender account id431        pub Allowances get(fn approved): double_map hasher(identity) CollectionId, hasher(twox_64_concat) (TokenId, T::AccountId, T::AccountId) => u128;432433        /// Item collections434        pub NftItemList get(fn nft_item_id) config(): double_map hasher(identity) CollectionId, hasher(identity) TokenId => NftItemType<T::AccountId>;435        pub FungibleItemList get(fn fungible_item_id) config(): double_map hasher(identity) CollectionId, hasher(twox_64_concat) T::AccountId => FungibleItemType;436        pub ReFungibleItemList get(fn refungible_item_id) config(): double_map hasher(identity) CollectionId, hasher(identity) TokenId => ReFungibleItemType<T::AccountId>;437438        /// Index list439        pub AddressTokens get(fn address_tokens): double_map hasher(identity) CollectionId, hasher(twox_64_concat) T::AccountId => Vec<TokenId>;440441        /// Tokens transfer baskets442        pub CreateItemBasket get(fn create_item_basket): map hasher(twox_64_concat) (CollectionId, T::AccountId) => T::BlockNumber;443        pub NftTransferBasket get(fn nft_transfer_basket): double_map hasher(identity) CollectionId, hasher(identity) TokenId => T::BlockNumber;444        pub FungibleTransferBasket get(fn fungible_transfer_basket): double_map hasher(identity) CollectionId, hasher(twox_64_concat) T::AccountId => T::BlockNumber;445        pub ReFungibleTransferBasket get(fn refungible_transfer_basket): double_map hasher(identity) CollectionId, hasher(identity) TokenId => T::BlockNumber;446447        // Contract Sponsorship and Ownership448        pub ContractOwner get(fn contract_owner): map hasher(twox_64_concat) T::AccountId => T::AccountId;449        pub ContractSelfSponsoring get(fn contract_self_sponsoring): map hasher(twox_64_concat) T::AccountId => bool;450        pub ContractSponsorBasket get(fn contract_sponsor_basket): map hasher(twox_64_concat) (T::AccountId, T::AccountId) => T::BlockNumber;451        pub ContractSponsoringRateLimit get(fn contract_sponsoring_rate_limit): map hasher(twox_64_concat) T::AccountId => T::BlockNumber;452        pub ContractWhiteListEnabled get(fn contract_white_list_enabled): map hasher(twox_64_concat) T::AccountId => bool; 453        pub ContractWhiteList get(fn contract_white_list): double_map hasher(twox_64_concat) T::AccountId, hasher(twox_64_concat) T::AccountId => bool; 454    }455    add_extra_genesis {456        build(|config: &GenesisConfig<T>| {457            // Modification of storage458            for (_num, _c) in &config.collection {459                <Module<T>>::init_collection(_c);460            }461462            for (_num, _c, _i) in &config.nft_item_id {463                <Module<T>>::init_nft_token(*_c, _i);464            }465466            for (collection_id, account_id, fungible_item) in &config.fungible_item_id {467                <Module<T>>::init_fungible_token(*collection_id, account_id, fungible_item);468            }469470            for (_num, _c, _i) in &config.refungible_item_id {471                <Module<T>>::init_refungible_token(*_c, _i);472            }473        })474    }475}476477decl_event!(478    pub enum Event<T>479    where480        AccountId = <T as system::Config>::AccountId,481    {482        /// New collection was created483        /// 484        /// # Arguments485        /// 486        /// * collection_id: Globally unique identifier of newly created collection.487        /// 488        /// * mode: [CollectionMode] converted into u8.489        /// 490        /// * account_id: Collection owner.491        Created(CollectionId, u8, AccountId),492493        /// New item was created.494        /// 495        /// # Arguments496        /// 497        /// * collection_id: Id of the collection where item was created.498        /// 499        /// * item_id: Id of an item. Unique within the collection.500        ///501        /// * recipient: Owner of newly created item 502        ItemCreated(CollectionId, TokenId, AccountId),503504        /// Collection item was burned.505        /// 506        /// # Arguments507        /// 508        /// collection_id.509        /// 510        /// item_id: Identifier of burned NFT.511        ItemDestroyed(CollectionId, TokenId),512513        /// Item was transferred514        ///515        /// * collection_id: Id of collection to which item is belong516        ///517        /// * item_id: Id of an item518        ///519        /// * sender: Original owner of item520        ///521        /// * recipient: New owner of item522        ///523        /// * amount: Always 1 for NFT524        Transfer(CollectionId, TokenId, AccountId, AccountId, u128),525    }526);527528decl_module! {529    pub struct Module<T: Config> for enum Call 530    where 531        origin: T::Origin532    {533        fn deposit_event() = default;534        type Error = Error<T>;535536        fn on_initialize(now: T::BlockNumber) -> Weight {537538            if ChainVersion::get() < 2539            {540                let value = NextCollectionID::get();541                CreatedCollectionCount::put(value);542                ChainVersion::put(2);543            }544545            0546        }547548        /// This method creates a Collection of NFTs. Each Token may have multiple properties encoded as an array of bytes of certain length. The initial owner and admin of the collection are set to the address that signed the transaction. Both addresses can be changed later.549        /// 550        /// # Permissions551        /// 552        /// * Anyone.553        /// 554        /// # Arguments555        /// 556        /// * collection_name: UTF-16 string with collection name (limit 64 characters), will be stored as zero-terminated.557        /// 558        /// * collection_description: UTF-16 string with collection description (limit 256 characters), will be stored as zero-terminated.559        /// 560        /// * token_prefix: UTF-8 string with token prefix.561        /// 562        /// * mode: [CollectionMode] collection type and type dependent data.563        // returns collection ID564        #[weight = <T as Config>::WeightInfo::create_collection()]565        pub fn create_collection(origin,566                                 collection_name: Vec<u16>,567                                 collection_description: Vec<u16>,568                                 token_prefix: Vec<u8>,569                                 mode: CollectionMode) -> DispatchResult {570571            // Anyone can create a collection572            let who = ensure_signed(origin)?;573574            let decimal_points = match mode {575                CollectionMode::Fungible(points) => points,576                _ => 0577            };578579            let chain_limit = ChainLimit::get();580581            // bound Total number of collections582            ensure!(CollectionCount::get() < chain_limit.collection_numbers_limit, Error::<T>::TotalCollectionsLimitExceeded);583584            // check params585            ensure!(decimal_points <= MAX_DECIMAL_POINTS, Error::<T>::CollectionDecimalPointLimitExceeded);586            ensure!(collection_name.len() <= 64, Error::<T>::CollectionNameLimitExceeded);587            ensure!(collection_description.len() <= 256, Error::<T>::CollectionDescriptionLimitExceeded);588            ensure!(token_prefix.len() <= 16, Error::<T>::CollectionTokenPrefixLimitExceeded);589590            // Generate next collection ID591            let next_id = CreatedCollectionCount::get()592                .checked_add(1)593                .ok_or(Error::<T>::NumOverflow)?;594595            // bound counter596            let total = CollectionCount::get()597                .checked_add(1)598                .ok_or(Error::<T>::NumOverflow)?;599600            CreatedCollectionCount::put(next_id);601            CollectionCount::put(total);602603            let limits = CollectionLimits {604                sponsored_data_size: chain_limit.custom_data_limit,605                ..Default::default()606            };607608            // Create new collection609            let new_collection = CollectionType {610                owner: who.clone(),611                name: collection_name,612                mode: mode.clone(),613                mint_mode: false,614                access: AccessMode::Normal,615                description: collection_description,616                decimal_points: decimal_points,617                token_prefix: token_prefix,618                offchain_schema: Vec::new(),619                schema_version: SchemaVersion::ImageURL,620                sponsor: T::AccountId::default(),621                sponsor_confirmed: false,622                variable_on_chain_schema: Vec::new(),623                const_on_chain_schema: Vec::new(),624                limits,625            };626627            // Add new collection to map628            <Collection<T>>::insert(next_id, new_collection);629630            // call event631            Self::deposit_event(RawEvent::Created(next_id, mode.into(), who.clone()));632633            Ok(())634        }635636        /// **DANGEROUS**: Destroys collection and all NFTs within this collection. Users irrecoverably lose their assets and may lose real money.637        /// 638        /// # Permissions639        /// 640        /// * Collection Owner.641        /// 642        /// # Arguments643        /// 644        /// * collection_id: collection to destroy.645        #[weight = <T as Config>::WeightInfo::destroy_collection()]646        pub fn destroy_collection(origin, collection_id: CollectionId) -> DispatchResult {647648            let sender = ensure_signed(origin)?;649            Self::check_owner_permissions(collection_id, sender)?;650651            let target_collection = <Collection<T>>::get(collection_id);652            if !target_collection.limits.owner_can_destroy {653                fail!(Error::<T>::NoPermission);654            }655656            <AddressTokens<T>>::remove_prefix(collection_id);657            <Allowances<T>>::remove_prefix(collection_id);658            <Balance<T>>::remove_prefix(collection_id);659            <ItemListIndex>::remove(collection_id);660            <AdminList<T>>::remove(collection_id);661            <Collection<T>>::remove(collection_id);662            <WhiteList<T>>::remove_prefix(collection_id);663664            <NftItemList<T>>::remove_prefix(collection_id);665            <FungibleItemList<T>>::remove_prefix(collection_id);666            <ReFungibleItemList<T>>::remove_prefix(collection_id);667668            <NftTransferBasket<T>>::remove_prefix(collection_id);669            <FungibleTransferBasket<T>>::remove_prefix(collection_id);670            <ReFungibleTransferBasket<T>>::remove_prefix(collection_id);671672            if CollectionCount::get() > 0673            {674                // bound couter675                let total = CollectionCount::get()676                    .checked_sub(1)677                    .ok_or(Error::<T>::NumOverflow)?;678679                CollectionCount::put(total);680            }681682            Ok(())683        }684685        /// Add an address to white list.686        /// 687        /// # Permissions688        /// 689        /// * Collection Owner690        /// * Collection Admin691        /// 692        /// # Arguments693        /// 694        /// * collection_id.695        /// 696        /// * address.697        #[weight = <T as Config>::WeightInfo::add_to_white_list()]698        pub fn add_to_white_list(origin, collection_id: CollectionId, address: T::AccountId) -> DispatchResult{699700            let sender = ensure_signed(origin)?;701            Self::check_owner_or_admin_permissions(collection_id, sender)?;702703            <WhiteList<T>>::insert(collection_id, address, true);704            705            Ok(())706        }707708        /// Remove an address from white list.709        /// 710        /// # Permissions711        /// 712        /// * Collection Owner713        /// * Collection Admin714        /// 715        /// # Arguments716        /// 717        /// * collection_id.718        /// 719        /// * address.720        #[weight = <T as Config>::WeightInfo::remove_from_white_list()]721        pub fn remove_from_white_list(origin, collection_id: CollectionId, address: T::AccountId) -> DispatchResult{722723            let sender = ensure_signed(origin)?;724            Self::check_owner_or_admin_permissions(collection_id, sender)?;725726            <WhiteList<T>>::remove(collection_id, address);727728            Ok(())729        }730731        /// Toggle between normal and white list access for the methods with access for `Anyone`.732        /// 733        /// # Permissions734        /// 735        /// * Collection Owner.736        /// 737        /// # Arguments738        /// 739        /// * collection_id.740        /// 741        /// * mode: [AccessMode]742        #[weight = <T as Config>::WeightInfo::set_public_access_mode()]743        pub fn set_public_access_mode(origin, collection_id: CollectionId, mode: AccessMode) -> DispatchResult744        {745            let sender = ensure_signed(origin)?;746747            Self::check_owner_permissions(collection_id, sender)?;748            let mut target_collection = <Collection<T>>::get(collection_id);749            target_collection.access = mode;750            <Collection<T>>::insert(collection_id, target_collection);751752            Ok(())753        }754755        /// Allows Anyone to create tokens if:756        /// * White List is enabled, and757        /// * Address is added to white list, and758        /// * This method was called with True parameter759        /// 760        /// # Permissions761        /// * Collection Owner762        ///763        /// # Arguments764        /// 765        /// * collection_id.766        /// 767        /// * mint_permission: Boolean parameter. If True, allows minting to Anyone with conditions above.768        #[weight = <T as Config>::WeightInfo::set_mint_permission()]769        pub fn set_mint_permission(origin, collection_id: CollectionId, mint_permission: bool) -> DispatchResult770        {771            let sender = ensure_signed(origin)?;772773            Self::check_owner_permissions(collection_id, sender)?;774            let mut target_collection = <Collection<T>>::get(collection_id);775            target_collection.mint_mode = mint_permission;776            <Collection<T>>::insert(collection_id, target_collection);777778            Ok(())779        }780781        /// Change the owner of the collection.782        /// 783        /// # Permissions784        /// 785        /// * Collection Owner.786        /// 787        /// # Arguments788        /// 789        /// * collection_id.790        /// 791        /// * new_owner.792        #[weight = <T as Config>::WeightInfo::change_collection_owner()]793        pub fn change_collection_owner(origin, collection_id: CollectionId, new_owner: T::AccountId) -> DispatchResult {794795            let sender = ensure_signed(origin)?;796            Self::check_owner_permissions(collection_id, sender)?;797            let mut target_collection = <Collection<T>>::get(collection_id);798            target_collection.owner = new_owner;799            <Collection<T>>::insert(collection_id, target_collection);800801            Ok(())802        }803804        /// Adds an admin of the Collection.805        /// NFT Collection can be controlled by multiple admin addresses (some which can also be servers, for example). Admins can issue and burn NFTs, as well as add and remove other admins, but cannot change NFT or Collection ownership. 806        /// 807        /// # Permissions808        /// 809        /// * Collection Owner.810        /// * Collection Admin.811        /// 812        /// # Arguments813        /// 814        /// * collection_id: ID of the Collection to add admin for.815        /// 816        /// * new_admin_id: Address of new admin to add.817        #[weight = <T as Config>::WeightInfo::add_collection_admin()]818        pub fn add_collection_admin(origin, collection_id: CollectionId, new_admin_id: T::AccountId) -> DispatchResult {819820            let sender = ensure_signed(origin)?;821            Self::check_owner_or_admin_permissions(collection_id, sender)?;822            let mut admin_arr: Vec<T::AccountId> = Vec::new();823824            if <AdminList<T>>::contains_key(collection_id)825            {826                admin_arr = <AdminList<T>>::get(collection_id);827                ensure!(!admin_arr.contains(&new_admin_id), Error::<T>::AlreadyAdmin);828            }829830            // Number of collection admins831            ensure!((admin_arr.len() as u64) < ChainLimit::get().collections_admins_limit, Error::<T>::CollectionAdminsLimitExceeded);832833            admin_arr.push(new_admin_id);834            <AdminList<T>>::insert(collection_id, admin_arr);835836            Ok(())837        }838839        /// Remove admin address of the Collection. An admin address can remove itself. List of admins may become empty, in which case only Collection Owner will be able to add an Admin.840        ///841        /// # Permissions842        /// 843        /// * Collection Owner.844        /// * Collection Admin.845        /// 846        /// # Arguments847        /// 848        /// * collection_id: ID of the Collection to remove admin for.849        /// 850        /// * account_id: Address of admin to remove.851        #[weight = <T as Config>::WeightInfo::remove_collection_admin()]852        pub fn remove_collection_admin(origin, collection_id: CollectionId, account_id: T::AccountId) -> DispatchResult {853854            let sender = ensure_signed(origin)?;855            Self::check_owner_or_admin_permissions(collection_id, sender)?;856            ensure!(<AdminList<T>>::contains_key(collection_id), Error::<T>::AdminNotFound);857858            let mut admin_arr = <AdminList<T>>::get(collection_id);859            admin_arr.retain(|i| *i != account_id);860            <AdminList<T>>::insert(collection_id, admin_arr);861862            Ok(())863        }864865        /// # Permissions866        /// 867        /// * Collection Owner868        /// 869        /// # Arguments870        /// 871        /// * collection_id.872        /// 873        /// * new_sponsor.874        #[weight = <T as Config>::WeightInfo::set_collection_sponsor()]875        pub fn set_collection_sponsor(origin, collection_id: CollectionId, new_sponsor: T::AccountId) -> DispatchResult {876877            let sender = ensure_signed(origin)?;878            ensure!(<Collection<T>>::contains_key(collection_id), Error::<T>::CollectionNotFound);879880            let mut target_collection = <Collection<T>>::get(collection_id);881            ensure!(sender == target_collection.owner, Error::<T>::NoPermission);882883            target_collection.sponsor = new_sponsor;884            target_collection.sponsor_confirmed = false;885            <Collection<T>>::insert(collection_id, target_collection);886887            Ok(())888        }889890        /// # Permissions891        /// 892        /// * Sponsor.893        /// 894        /// # Arguments895        /// 896        /// * collection_id.897        #[weight = <T as Config>::WeightInfo::confirm_sponsorship()]898        pub fn confirm_sponsorship(origin, collection_id: CollectionId) -> DispatchResult {899900            let sender = ensure_signed(origin)?;901            ensure!(<Collection<T>>::contains_key(collection_id), Error::<T>::CollectionNotFound);902903            let mut target_collection = <Collection<T>>::get(collection_id);904            ensure!(sender == target_collection.sponsor, Error::<T>::ConfirmUnsetSponsorFail);905906            target_collection.sponsor_confirmed = true;907            <Collection<T>>::insert(collection_id, target_collection);908909            Ok(())910        }911912        /// Switch back to pay-per-own-transaction model.913        ///914        /// # Permissions915        ///916        /// * Collection owner.917        /// 918        /// # Arguments919        /// 920        /// * collection_id.921        #[weight = <T as Config>::WeightInfo::remove_collection_sponsor()]922        pub fn remove_collection_sponsor(origin, collection_id: CollectionId) -> DispatchResult {923924            let sender = ensure_signed(origin)?;925            ensure!(<Collection<T>>::contains_key(collection_id), Error::<T>::CollectionNotFound);926927            let mut target_collection = <Collection<T>>::get(collection_id);928            ensure!(sender == target_collection.owner, Error::<T>::NoPermission);929930            target_collection.sponsor = T::AccountId::default();931            target_collection.sponsor_confirmed = false;932            <Collection<T>>::insert(collection_id, target_collection);933934            Ok(())935        }936937        /// This method creates a concrete instance of NFT Collection created with CreateCollection method.938        /// 939        /// # Permissions940        /// 941        /// * Collection Owner.942        /// * Collection Admin.943        /// * Anyone if944        ///     * White List is enabled, and945        ///     * Address is added to white list, and946        ///     * MintPermission is enabled (see SetMintPermission method)947        /// 948        /// # Arguments949        /// 950        /// * collection_id: ID of the collection.951        /// 952        /// * owner: Address, initial owner of the NFT.953        ///954        /// * data: Token data to store on chain.955        // #[weight =956        // (130_000_000 as Weight)957        // .saturating_add((2135 as Weight).saturating_mul((properties.len() as u64) as Weight))958        // .saturating_add(RocksDbWeight::get().reads(10 as Weight))959        // .saturating_add(RocksDbWeight::get().writes(8 as Weight))]960961        #[weight = <T as Config>::WeightInfo::create_item(data.len())]962        pub fn create_item(origin, collection_id: CollectionId, owner: T::AccountId, data: CreateItemData) -> DispatchResult {963964            let sender = ensure_signed(origin)?;965966            Self::collection_exists(collection_id)?;967968            let target_collection = <Collection<T>>::get(collection_id);969970            Self::can_create_items_in_collection(collection_id, &target_collection, &sender, &owner)?;971            Self::validate_create_item_args(&target_collection, &data)?;972            Self::create_item_no_validation(collection_id, owner, data)?;973974            Ok(())975        }976977        /// This method creates multiple instances of NFT Collection created with CreateCollection method.978        /// 979        /// # Permissions980        /// 981        /// * Collection Owner.982        /// * Collection Admin.983        /// * Anyone if984        ///     * White List is enabled, and985        ///     * Address is added to white list, and986        ///     * MintPermission is enabled (see SetMintPermission method)987        /// 988        /// # Arguments989        /// 990        /// * collection_id: ID of the collection.991        /// 992        /// * itemsData: Array items properties. Each property is an array of bytes itself, see [create_item].993        /// 994        /// * owner: Address, initial owner of the NFT.995        #[weight = <T as Config>::WeightInfo::create_item(items_data.into_iter()996                               .map(|data| { data.len() })997                               .sum())]998        pub fn create_multiple_items(origin, collection_id: CollectionId, owner: T::AccountId, items_data: Vec<CreateItemData>) -> DispatchResult {9991000            ensure!(items_data.len() > 0, Error::<T>::EmptyArgument);1001            let sender = ensure_signed(origin)?;10021003            Self::collection_exists(collection_id)?;1004            let target_collection = <Collection<T>>::get(collection_id);10051006            Self::can_create_items_in_collection(collection_id, &target_collection, &sender, &owner)?;10071008            for data in &items_data {1009                Self::validate_create_item_args(&target_collection, data)?;1010            }1011            for data in &items_data {1012                Self::create_item_no_validation(collection_id, owner.clone(), data.clone())?;1013            }10141015            Ok(())1016        }10171018        /// Destroys a concrete instance of NFT.1019        /// 1020        /// # Permissions1021        /// 1022        /// * Collection Owner.1023        /// * Collection Admin.1024        /// * Current NFT Owner.1025        /// 1026        /// # Arguments1027        /// 1028        /// * collection_id: ID of the collection.1029        /// 1030        /// * item_id: ID of NFT to burn.1031        #[weight = <T as Config>::WeightInfo::burn_item()]1032        pub fn burn_item(origin, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {10331034            let sender = ensure_signed(origin)?;1035            Self::collection_exists(collection_id)?;10361037            // Transfer permissions check1038            let target_collection = <Collection<T>>::get(collection_id);1039            ensure!(1040                Self::is_item_owner(sender.clone(), collection_id, item_id) ||1041                (1042                    target_collection.limits.owner_can_transfer &&1043                    Self::is_owner_or_admin_permissions(collection_id, sender.clone())1044                ),1045                Error::<T>::NoPermission1046            );10471048            if target_collection.access == AccessMode::WhiteList {1049                Self::check_white_list(collection_id, &sender)?;1050            }10511052            match target_collection.mode1053            {1054                CollectionMode::NFT => Self::burn_nft_item(collection_id, item_id)?,1055                CollectionMode::Fungible(_)  => Self::burn_fungible_item(&sender, collection_id, value)?,1056                CollectionMode::ReFungible  => Self::burn_refungible_item(collection_id, item_id, &sender)?,1057                _ => ()1058            };10591060            // call event1061            Self::deposit_event(RawEvent::ItemDestroyed(collection_id, item_id));10621063            Ok(())1064        }10651066        /// Change ownership of the token.1067        /// 1068        /// # Permissions1069        /// 1070        /// * Collection Owner1071        /// * Collection Admin1072        /// * Current NFT owner1073        ///1074        /// # Arguments1075        /// 1076        /// * recipient: Address of token recipient.1077        /// 1078        /// * collection_id.1079        /// 1080        /// * item_id: ID of the item1081        ///     * Non-Fungible Mode: Required.1082        ///     * Fungible Mode: Ignored.1083        ///     * Re-Fungible Mode: Required.1084        /// 1085        /// * value: Amount to transfer.1086        ///     * Non-Fungible Mode: Ignored1087        ///     * Fungible Mode: Must specify transferred amount1088        ///     * Re-Fungible Mode: Must specify transferred portion (between 0 and 1)1089        #[weight = <T as Config>::WeightInfo::transfer()]1090        pub fn transfer(origin, recipient: T::AccountId, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {1091            let sender = ensure_signed(origin)?;1092            Self::transfer_internal(sender, recipient, collection_id, item_id, value)1093        }10941095        /// Set, change, or remove approved address to transfer the ownership of the NFT.1096        /// 1097        /// # Permissions1098        /// 1099        /// * Collection Owner1100        /// * Collection Admin1101        /// * Current NFT owner1102        /// 1103        /// # Arguments1104        /// 1105        /// * approved: Address that is approved to transfer this NFT or zero (if needed to remove approval).1106        /// 1107        /// * collection_id.1108        /// 1109        /// * item_id: ID of the item.1110        #[weight = <T as Config>::WeightInfo::approve()]1111        pub fn approve(origin, spender: T::AccountId, collection_id: CollectionId, item_id: TokenId, amount: u128) -> DispatchResult {11121113            let sender = ensure_signed(origin)?;11141115            Self::collection_exists(collection_id)?;1116            Self::token_exists(collection_id, item_id, &sender)?;11171118            // Transfer permissions check1119            let target_collection = <Collection<T>>::get(collection_id);1120            let allowance_limit = if target_collection.limits.owner_can_transfer &&1121                Self::is_owner_or_admin_permissions(1122                    collection_id,1123                    sender.clone(),1124                ) {1125                None1126            } else if let Some(amount) = Self::owned_amount(1127                sender.clone(),1128                collection_id,1129                item_id,1130            ) {1131                Some(amount)1132            } else {1133                fail!(Error::<T>::NoPermission);1134            };11351136            if target_collection.access == AccessMode::WhiteList {1137                Self::check_white_list(collection_id, &sender)?;1138                Self::check_white_list(collection_id, &spender)?;1139            }11401141            let allowance_exists = <Allowances<T>>::contains_key(collection_id, (item_id, &sender, &spender));1142            let mut allowance: u128 = amount;1143            if allowance_exists {1144                allowance += <Allowances<T>>::get(collection_id, (item_id, &sender, &spender));1145            }1146            if let Some(limit) = allowance_limit {1147                ensure!(limit >= allowance, Error::<T>::TokenValueTooLow);1148            }1149            <Allowances<T>>::insert(collection_id, (item_id, sender.clone(), spender.clone()), allowance);11501151            Ok(())1152        }1153        1154        /// Change ownership of a NFT on behalf of the owner. See Approve method for additional information. After this method executes, the approval is removed so that the approved address will not be able to transfer this NFT again from this owner.1155        /// 1156        /// # Permissions1157        /// * Collection Owner1158        /// * Collection Admin1159        /// * Current NFT owner1160        /// * Address approved by current NFT owner1161        /// 1162        /// # Arguments1163        /// 1164        /// * from: Address that owns token.1165        /// 1166        /// * recipient: Address of token recipient.1167        /// 1168        /// * collection_id.1169        /// 1170        /// * item_id: ID of the item.1171        /// 1172        /// * value: Amount to transfer.1173        #[weight = <T as Config>::WeightInfo::transfer_from()]1174        pub fn transfer_from(origin, from: T::AccountId, recipient: T::AccountId, collection_id: CollectionId, item_id: TokenId, value: u128 ) -> DispatchResult {11751176            let sender = ensure_signed(origin)?;1177            let mut appoved_transfer = false;11781179            // Check approval1180            let mut approval: u128 = 0;1181            if <Allowances<T>>::contains_key(collection_id, (item_id, &from, &sender)) {1182                approval = <Allowances<T>>::get(collection_id, (item_id, &from, &sender));1183                ensure!(approval >= value, Error::<T>::TokenValueNotEnough);1184                appoved_transfer = true;1185            }11861187            let target_collection = <Collection<T>>::get(collection_id);11881189            // Limits check1190            Self::is_correct_transfer(collection_id, &target_collection, &recipient)?;11911192            // Transfer permissions check         1193            ensure!(1194                appoved_transfer || 1195                (1196                    target_collection.limits.owner_can_transfer &&1197                    Self::is_owner_or_admin_permissions(collection_id, sender.clone())1198                ),1199                Error::<T>::NoPermission1200            );12011202            if target_collection.access == AccessMode::WhiteList {1203                Self::check_white_list(collection_id, &sender)?;1204                Self::check_white_list(collection_id, &recipient)?;1205            }12061207            // Reduce approval by transferred amount or remove if remaining approval drops to 01208            if approval.checked_sub(value).unwrap_or(0) > 0 {1209                <Allowances<T>>::insert(collection_id, (item_id, &from, &sender), approval - value);1210            }1211            else {1212                <Allowances<T>>::remove(collection_id, (item_id, &from, &sender));1213            }12141215            match target_collection.mode1216            {1217                CollectionMode::NFT => Self::transfer_nft(collection_id, item_id, from, recipient)?,1218                CollectionMode::Fungible(_)  => Self::transfer_fungible(collection_id, value, &from, &recipient)?,1219                CollectionMode::ReFungible  => Self::transfer_refungible(collection_id, item_id, value, from.clone(), recipient)?,1220                _ => ()1221            };12221223            Ok(())1224        }12251226        // #[weight = 0]1227        // pub fn safe_transfer_from(origin, collection_id: CollectionId, item_id: TokenId, new_owner: T::AccountId) -> DispatchResult {12281229        //     // let no_perm_mes = "You do not have permissions to modify this collection";1230        //     // ensure!(<ApprovedList<T>>::contains_key((collection_id, item_id)), no_perm_mes);1231        //     // let list_itm = <ApprovedList<T>>::get((collection_id, item_id));1232        //     // ensure!(list_itm.contains(&new_owner.clone()), no_perm_mes);12331234        //     // // on_nft_received  call12351236        //     // Self::transfer(origin, collection_id, item_id, new_owner)?;12371238        //     Ok(())1239        // }12401241        /// Set off-chain data schema.1242        /// 1243        /// # Permissions1244        /// 1245        /// * Collection Owner1246        /// * Collection Admin1247        /// 1248        /// # Arguments1249        /// 1250        /// * collection_id.1251        /// 1252        /// * schema: String representing the offchain data schema.1253        #[weight = <T as Config>::WeightInfo::set_variable_meta_data()]1254        pub fn set_variable_meta_data (1255            origin,1256            collection_id: CollectionId,1257            item_id: TokenId,1258            data: Vec<u8>1259        ) -> DispatchResult {1260            let sender = ensure_signed(origin)?;1261            1262            Self::collection_exists(collection_id)?;1263            Self::token_exists(collection_id, item_id, &sender)?;12641265            ensure!(ChainLimit::get().custom_data_limit >= data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);12661267            // Modify permissions check1268            let target_collection = <Collection<T>>::get(collection_id);1269            ensure!(Self::is_item_owner(sender.clone(), collection_id, item_id) ||1270                Self::is_owner_or_admin_permissions(collection_id, sender.clone()),1271                Error::<T>::NoPermission);12721273            match target_collection.mode1274            {1275                CollectionMode::NFT => Self::set_nft_variable_data(collection_id, item_id, data)?,1276                CollectionMode::ReFungible  => Self::set_re_fungible_variable_data(collection_id, item_id, data)?,1277                CollectionMode::Fungible(_) => fail!(Error::<T>::CantStoreMetadataInFungibleTokens),1278                _ => fail!(Error::<T>::UnexpectedCollectionType)1279            };12801281            Ok(())1282        }1283 1284        /// Set schema standard1285        /// ImageURL1286        /// Unique1287        /// 1288        /// # Permissions1289        /// 1290        /// * Collection Owner1291        /// * Collection Admin1292        /// 1293        /// # Arguments1294        /// 1295        /// * collection_id.1296        /// 1297        /// * schema: SchemaVersion: enum1298        #[weight = <T as Config>::WeightInfo::set_schema_version()]1299        pub fn set_schema_version(1300            origin,1301            collection_id: CollectionId,1302            version: SchemaVersion1303        ) -> DispatchResult {1304            let sender = ensure_signed(origin)?;1305            Self::check_owner_or_admin_permissions(collection_id, sender.clone())?;1306            let mut target_collection = <Collection<T>>::get(collection_id);1307            target_collection.schema_version = version;1308            <Collection<T>>::insert(collection_id, target_collection);13091310            Ok(())1311        }13121313        /// Set off-chain data schema.1314        /// 1315        /// # Permissions1316        /// 1317        /// * Collection Owner1318        /// * Collection Admin1319        /// 1320        /// # Arguments1321        /// 1322        /// * collection_id.1323        /// 1324        /// * schema: String representing the offchain data schema.1325        #[weight = <T as Config>::WeightInfo::set_offchain_schema()]1326        pub fn set_offchain_schema(1327            origin,1328            collection_id: CollectionId,1329            schema: Vec<u8>1330        ) -> DispatchResult {1331            let sender = ensure_signed(origin)?;1332            Self::check_owner_or_admin_permissions(collection_id, sender.clone())?;13331334            // check schema limit1335            ensure!(schema.len() as u32 <= ChainLimit::get().offchain_schema_limit, "");13361337            let mut target_collection = <Collection<T>>::get(collection_id);1338            target_collection.offchain_schema = schema;1339            <Collection<T>>::insert(collection_id, target_collection);13401341            Ok(())1342        }13431344        /// Set const on-chain data schema.1345        /// 1346        /// # Permissions1347        /// 1348        /// * Collection Owner1349        /// * Collection Admin1350        /// 1351        /// # Arguments1352        /// 1353        /// * collection_id.1354        /// 1355        /// * schema: String representing the const on-chain data schema.1356        #[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1357        pub fn set_const_on_chain_schema (1358            origin,1359            collection_id: CollectionId,1360            schema: Vec<u8>1361        ) -> DispatchResult {1362            let sender = ensure_signed(origin)?;1363            Self::check_owner_or_admin_permissions(collection_id, sender.clone())?;13641365            // check schema limit1366            ensure!(schema.len() as u32 <= ChainLimit::get().const_on_chain_schema_limit, "");13671368            let mut target_collection = <Collection<T>>::get(collection_id);1369            target_collection.const_on_chain_schema = schema;1370            <Collection<T>>::insert(collection_id, target_collection);13711372            Ok(())1373        }13741375        /// Set variable on-chain data schema.1376        /// 1377        /// # Permissions1378        /// 1379        /// * Collection Owner1380        /// * Collection Admin1381        /// 1382        /// # Arguments1383        /// 1384        /// * collection_id.1385        /// 1386        /// * schema: String representing the variable on-chain data schema.1387        #[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1388        pub fn set_variable_on_chain_schema (1389            origin,1390            collection_id: CollectionId,1391            schema: Vec<u8>1392        ) -> DispatchResult {1393            let sender = ensure_signed(origin)?;1394            Self::check_owner_or_admin_permissions(collection_id, sender.clone())?;13951396            // check schema limit1397            ensure!(schema.len() as u32 <= ChainLimit::get().variable_on_chain_schema_limit, "");13981399            let mut target_collection = <Collection<T>>::get(collection_id);1400            target_collection.variable_on_chain_schema = schema;1401            <Collection<T>>::insert(collection_id, target_collection);14021403            Ok(())1404        }14051406        // Sudo permissions function1407        #[weight = <T as Config>::WeightInfo::set_chain_limits()]1408        pub fn set_chain_limits(1409            origin,1410            limits: ChainLimits1411        ) -> DispatchResult {14121413            #[cfg(not(feature = "runtime-benchmarks"))]1414            ensure_root(origin)?;14151416            <ChainLimit>::put(limits);1417            Ok(())1418        }14191420        /// Enable smart contract self-sponsoring.1421        /// 1422        /// # Permissions1423        /// 1424        /// * Contract Owner1425        /// 1426        /// # Arguments1427        /// 1428        /// * contract address1429        /// * enable flag1430        /// 1431        #[weight = <T as Config>::WeightInfo::enable_contract_sponsoring()]1432        pub fn enable_contract_sponsoring(1433            origin,1434            contract_address: T::AccountId,1435            enable: bool1436        ) -> DispatchResult {14371438            let sender = ensure_signed(origin)?;14391440            #[cfg(feature = "runtime-benchmarks")]1441            <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());14421443            Self::ensure_contract_owned(sender, &contract_address)?;14441445            <ContractSelfSponsoring<T>>::insert(contract_address, enable);1446            Ok(())1447        }14481449        /// Set the rate limit for contract sponsoring to specified number of blocks.1450        /// 1451        /// If not set (has the default value of 0 blocks), the sponsoring will be disabled. 1452        /// If set to the number B (for blocks), the transactions will be sponsored with a rate 1453        /// limit of B, i.e. fees for every transaction sent to this smart contract will be paid 1454        /// from contract endowment if there are at least B blocks between such transactions. 1455        /// Nonetheless, if transactions are sent more frequently, the fees are paid by the sender.1456        /// 1457        /// # Permissions1458        /// 1459        /// * Contract Owner1460        /// 1461        /// # Arguments1462        /// 1463        /// -`contract_address`: Address of the contract to sponsor1464        /// -`rate_limit`: Number of blocks to wait until the next sponsored transaction is allowed1465        /// 1466        #[weight = <T as Config>::WeightInfo::set_contract_sponsoring_rate_limit()]1467        pub fn set_contract_sponsoring_rate_limit(1468            origin,1469            contract_address: T::AccountId,1470            rate_limit: T::BlockNumber1471        ) -> DispatchResult {1472            let sender = ensure_signed(origin)?;14731474            #[cfg(feature = "runtime-benchmarks")]1475            <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());14761477            Self::ensure_contract_owned(sender, &contract_address)?;1478            <ContractSponsoringRateLimit<T>>::insert(contract_address, rate_limit);1479            Ok(())1480        }14811482        /// Enable the white list for a contract. Only addresses added to the white list with addToContractWhiteList will be able to call this smart contract.1483        /// 1484        /// # Permissions1485        /// 1486        /// * Address that deployed smart contract.1487        /// 1488        /// # Arguments1489        /// 1490        /// -`contract_address`: Address of the contract.1491        /// 1492        /// - `enable`: .  1493        #[weight = <T as Config>::WeightInfo::toggle_contract_white_list()]1494        pub fn toggle_contract_white_list(1495            origin,1496            contract_address: T::AccountId,1497            enable: bool1498        ) -> DispatchResult {1499            let sender = ensure_signed(origin)?;15001501            #[cfg(feature = "runtime-benchmarks")]1502            <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());15031504            Self::ensure_contract_owned(sender, &contract_address)?;1505            <ContractWhiteListEnabled<T>>::insert(contract_address, enable);1506            Ok(())1507        }1508        1509        /// Add an address to smart contract white list.1510        /// 1511        /// # Permissions1512        /// 1513        /// * Address that deployed smart contract.1514        /// 1515        /// # Arguments1516        /// 1517        /// -`contract_address`: Address of the contract.1518        ///1519        /// -`account_address`: Address to add.1520        #[weight = <T as Config>::WeightInfo::add_to_contract_white_list()]1521        pub fn add_to_contract_white_list(1522            origin,1523            contract_address: T::AccountId,1524            account_address: T::AccountId1525        ) -> DispatchResult {1526            let sender = ensure_signed(origin)?;15271528            #[cfg(feature = "runtime-benchmarks")]1529            <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());1530            1531            Self::ensure_contract_owned(sender, &contract_address)?;      1532            <ContractWhiteList<T>>::insert(contract_address, account_address, true);1533            Ok(())1534        }15351536        /// Remove an address from smart contract white list.1537        /// 1538        /// # Permissions1539        /// 1540        /// * Address that deployed smart contract.1541        /// 1542        /// # Arguments1543        /// 1544        /// -`contract_address`: Address of the contract.1545        ///1546        /// -`account_address`: Address to remove.1547        #[weight = <T as Config>::WeightInfo::remove_from_contract_white_list()]1548        pub fn remove_from_contract_white_list(1549            origin,1550            contract_address: T::AccountId,1551            account_address: T::AccountId1552        ) -> DispatchResult {1553            let sender = ensure_signed(origin)?;15541555            #[cfg(feature = "runtime-benchmarks")]1556            <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());15571558            Self::ensure_contract_owned(sender, &contract_address)?;1559            <ContractWhiteList<T>>::remove(contract_address, account_address);1560            Ok(())1561        }15621563        #[weight = <T as Config>::WeightInfo::set_collection_limits()]1564        pub fn set_collection_limits(1565            origin,1566            collection_id: u32,1567            new_limits: CollectionLimits,1568        ) -> DispatchResult {1569            let sender = ensure_signed(origin)?;1570            Self::check_owner_permissions(collection_id, sender.clone())?;1571            let mut target_collection = <Collection<T>>::get(collection_id);1572            let old_limits = target_collection.limits;1573            let chain_limits = ChainLimit::get();15741575            // collection bounds1576            ensure!(new_limits.sponsor_transfer_timeout <= MAX_SPONSOR_TIMEOUT &&1577                new_limits.account_token_ownership_limit <= MAX_TOKEN_OWNERSHIP && 1578                new_limits.sponsored_data_size <= chain_limits.custom_data_limit,1579                Error::<T>::CollectionLimitBoundsExceeded);15801581            // token_limit   check  prev1582            ensure!(old_limits.token_limit >= new_limits.token_limit, Error::<T>::CollectionTokenLimitExceeded);1583            ensure!(new_limits.token_limit > 0, Error::<T>::CollectionTokenLimitExceeded);15841585            ensure!(1586                (old_limits.owner_can_transfer || !new_limits.owner_can_transfer) &&1587                (old_limits.owner_can_destroy || !new_limits.owner_can_destroy),1588                Error::<T>::OwnerPermissionsCantBeReverted,1589            );15901591            target_collection.limits = new_limits;1592            <Collection<T>>::insert(collection_id, target_collection);15931594            Ok(())1595        } 1596    }1597}15981599impl<T: Config> Module<T> {16001601    pub fn transfer_internal(sender: T::AccountId, recipient: T::AccountId, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {16021603        let target_collection = <Collection<T>>::get(collection_id);16041605        // Limits check1606        Self::is_correct_transfer(collection_id, &target_collection, &recipient)?;16071608        // Transfer permissions check1609        ensure!(Self::is_item_owner(sender.clone(), collection_id, item_id) ||1610            Self::is_owner_or_admin_permissions(collection_id, sender.clone()),1611            Error::<T>::NoPermission);16121613        if target_collection.access == AccessMode::WhiteList {1614            Self::check_white_list(collection_id, &sender)?;1615            Self::check_white_list(collection_id, &recipient)?;1616        }16171618        match target_collection.mode1619        {1620            CollectionMode::NFT => Self::transfer_nft(collection_id, item_id, sender.clone(), recipient.clone())?,1621            CollectionMode::Fungible(_)  => Self::transfer_fungible(collection_id, value, &sender, &recipient)?,1622            CollectionMode::ReFungible  => Self::transfer_refungible(collection_id, item_id, value, sender.clone(), recipient.clone())?,1623            _ => ()1624        };16251626        Self::deposit_event(RawEvent::Transfer(collection_id, item_id, sender, recipient, value));16271628        Ok(())1629    }163016311632    fn is_correct_transfer(collection_id: CollectionId, collection: &CollectionType<T::AccountId>, recipient: &T::AccountId) -> DispatchResult {16331634        // check token limit and account token limit1635        let account_items: u32 = <AddressTokens<T>>::get(collection_id, recipient).len() as u32;1636        ensure!(collection.limits.account_token_ownership_limit > account_items,  Error::<T>::AccountTokenLimitExceeded);1637        1638        Ok(())1639    }16401641    fn can_create_items_in_collection(collection_id: CollectionId, collection: &CollectionType<T::AccountId>, sender: &T::AccountId, owner: &T::AccountId) -> DispatchResult {16421643        // check token limit and account token limit1644        let total_items: u32 = ItemListIndex::get(collection_id);1645        let account_items: u32 = <AddressTokens<T>>::get(collection_id, owner).len() as u32;1646        ensure!(collection.limits.token_limit > total_items,  Error::<T>::CollectionTokenLimitExceeded);1647        ensure!(collection.limits.account_token_ownership_limit > account_items,  Error::<T>::AccountTokenLimitExceeded);16481649        if !Self::is_owner_or_admin_permissions(collection_id, sender.clone()) {1650            ensure!(collection.mint_mode == true, Error::<T>::PublicMintingNotAllowed);1651            Self::check_white_list(collection_id, owner)?;1652            Self::check_white_list(collection_id, sender)?;1653        }16541655        Ok(())1656    }16571658    fn validate_create_item_args(target_collection: &CollectionType<T::AccountId>, data: &CreateItemData) -> DispatchResult {1659        match target_collection.mode1660        {1661            CollectionMode::NFT => {1662                if let CreateItemData::NFT(data) = data {1663                    // check sizes1664                    ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, Error::<T>::TokenConstDataLimitExceeded);1665                    ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);1666                } else {1667                    fail!(Error::<T>::NotNftDataUsedToMintNftCollectionToken);1668                }1669            },1670            CollectionMode::Fungible(_) => {1671                if let CreateItemData::Fungible(_) = data {1672                } else {1673                    fail!(Error::<T>::NotFungibleDataUsedToMintFungibleCollectionToken);1674                }1675            },1676            CollectionMode::ReFungible => {1677                if let CreateItemData::ReFungible(data) = data {16781679                    // check sizes1680                    ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, Error::<T>::TokenConstDataLimitExceeded);1681                    ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);16821683                    // Check refungibility limits1684                    ensure!(data.pieces <= MAX_REFUNGIBLE_PIECES, Error::<T>::WrongRefungiblePieces);1685                    ensure!(data.pieces > 0, Error::<T>::WrongRefungiblePieces);1686                } else {1687                    fail!(Error::<T>::NotReFungibleDataUsedToMintReFungibleCollectionToken);1688                }1689            },1690            _ => { fail!(Error::<T>::UnexpectedCollectionType); }1691        };16921693        Ok(())1694    }16951696    fn create_item_no_validation(collection_id: CollectionId, owner: T::AccountId, data: CreateItemData) -> DispatchResult {1697        match data1698        {1699            CreateItemData::NFT(data) => {1700                let item = NftItemType {1701                    owner: owner.clone(),1702                    const_data: data.const_data,1703                    variable_data: data.variable_data1704                };17051706                Self::add_nft_item(collection_id, item)?;1707            },1708            CreateItemData::Fungible(data) => {1709                Self::add_fungible_item(collection_id, &owner, data.value)?;1710            },1711            CreateItemData::ReFungible(data) => {1712                let mut owner_list = Vec::new();1713                owner_list.push(Ownership {owner: owner.clone(), fraction: data.pieces});17141715                let item = ReFungibleItemType {1716                    owner: owner_list,1717                    const_data: data.const_data,1718                    variable_data: data.variable_data1719                };17201721                Self::add_refungible_item(collection_id, item)?;1722            }1723        };17241725        // call event1726        Self::deposit_event(RawEvent::ItemCreated(collection_id, <ItemListIndex>::get(collection_id), owner));17271728        Ok(())1729    }17301731    fn add_fungible_item(collection_id: CollectionId, owner: &T::AccountId, value: u128) -> DispatchResult {17321733        // Does new owner already have an account?1734        let mut balance: u128 = 0;1735        if <FungibleItemList<T>>::contains_key(collection_id, owner) {1736            balance = <FungibleItemList<T>>::get(collection_id, owner).value;1737        } 17381739        // Mint 1740        let item = FungibleItemType {1741            value: balance + value1742        };1743        <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), item);17441745        // Update balance1746        let new_balance = <Balance<T>>::get(collection_id, owner)1747            .checked_add(value)1748            .ok_or(Error::<T>::NumOverflow)?;1749        <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);17501751        Ok(())1752    }17531754    fn add_refungible_item(collection_id: CollectionId, item: ReFungibleItemType<T::AccountId>) -> DispatchResult {1755        let current_index = <ItemListIndex>::get(collection_id)1756            .checked_add(1)1757            .ok_or(Error::<T>::NumOverflow)?;1758        let itemcopy = item.clone();17591760        let value = item.owner.first().unwrap().fraction;1761        let owner = item.owner.first().unwrap().owner.clone();17621763        Self::add_token_index(collection_id, current_index, &owner)?;17641765        <ItemListIndex>::insert(collection_id, current_index);1766        <ReFungibleItemList<T>>::insert(collection_id, current_index, itemcopy);17671768        // Update balance1769        let new_balance = <Balance<T>>::get(collection_id, &owner)1770            .checked_add(value)1771            .ok_or(Error::<T>::NumOverflow)?;1772        <Balance<T>>::insert(collection_id, owner.clone(), new_balance);17731774        Ok(())1775    }17761777    fn add_nft_item(collection_id: CollectionId, item: NftItemType<T::AccountId>) -> DispatchResult {1778        let current_index = <ItemListIndex>::get(collection_id)1779            .checked_add(1)1780            .ok_or(Error::<T>::NumOverflow)?;17811782        let item_owner = item.owner.clone();1783        Self::add_token_index(collection_id, current_index, &item.owner)?;17841785        <ItemListIndex>::insert(collection_id, current_index);1786        <NftItemList<T>>::insert(collection_id, current_index, item);17871788        // Update balance1789        let new_balance = <Balance<T>>::get(collection_id, item_owner.clone())1790            .checked_add(1)1791            .ok_or(Error::<T>::NumOverflow)?;1792        <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);17931794        Ok(())1795    }17961797    fn burn_refungible_item(1798        collection_id: CollectionId,1799        item_id: TokenId,1800        owner: &T::AccountId,1801    ) -> DispatchResult {1802        ensure!(1803            <ReFungibleItemList<T>>::contains_key(collection_id, item_id),1804            Error::<T>::TokenNotFound1805        );1806        let mut token = <ReFungibleItemList<T>>::get(collection_id, item_id);1807        let rft_balance = token1808            .owner1809            .iter()1810            .filter(|&i| i.owner == *owner)1811            .next()1812            .unwrap();1813        Self::remove_token_index(collection_id, item_id, owner)?;18141815        // update balance1816        let new_balance = <Balance<T>>::get(collection_id, rft_balance.owner.clone())1817            .checked_sub(rft_balance.fraction)1818            .ok_or(Error::<T>::NumOverflow)?;1819        <Balance<T>>::insert(collection_id, rft_balance.owner.clone(), new_balance);18201821        // Re-create owners list with sender removed1822        let index = token1823            .owner1824            .iter()1825            .position(|i| i.owner == *owner)1826            .unwrap();1827        token.owner.remove(index);1828        let owner_count = token.owner.len();18291830        // Burn the token completely if this was the last (only) owner1831        if owner_count == 0 {1832            <ReFungibleItemList<T>>::remove(collection_id, item_id);1833        }1834        else {1835            <ReFungibleItemList<T>>::insert(collection_id, item_id, token);1836        }18371838        Ok(())1839    }18401841    fn burn_nft_item(collection_id: CollectionId, item_id: TokenId) -> DispatchResult {1842        ensure!(1843            <NftItemList<T>>::contains_key(collection_id, item_id),1844            Error::<T>::TokenNotFound1845        );1846        let item = <NftItemList<T>>::get(collection_id, item_id);1847        Self::remove_token_index(collection_id, item_id, &item.owner)?;18481849        // update balance1850        let new_balance = <Balance<T>>::get(collection_id, &item.owner)1851            .checked_sub(1)1852            .ok_or(Error::<T>::NumOverflow)?;1853        <Balance<T>>::insert(collection_id, item.owner.clone(), new_balance);1854        <NftItemList<T>>::remove(collection_id, item_id);18551856        Ok(())1857    }18581859    fn burn_fungible_item(owner: &T::AccountId, collection_id: CollectionId, value: u128) -> DispatchResult {1860        ensure!(1861            <FungibleItemList<T>>::contains_key(collection_id, owner),1862            Error::<T>::TokenNotFound1863        );1864        let mut balance = <FungibleItemList<T>>::get(collection_id, owner);1865        ensure!(balance.value >= value, Error::<T>::TokenValueNotEnough);18661867        // update balance1868        let new_balance = <Balance<T>>::get(collection_id, owner)1869            .checked_sub(value)1870            .ok_or(Error::<T>::NumOverflow)?;1871        <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);18721873        if balance.value - value > 0 {1874            balance.value -= value;1875            <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), balance);1876        }1877        else {1878            <FungibleItemList<T>>::remove(collection_id, owner);1879        }18801881        Ok(())1882    }18831884    fn collection_exists(collection_id: CollectionId) -> DispatchResult {1885        ensure!(1886            <Collection<T>>::contains_key(collection_id),1887            Error::<T>::CollectionNotFound1888        );1889        Ok(())1890    }18911892    fn check_owner_permissions(collection_id: CollectionId, subject: T::AccountId) -> DispatchResult {1893        Self::collection_exists(collection_id)?;18941895        let target_collection = <Collection<T>>::get(collection_id);1896        ensure!(1897            subject == target_collection.owner,1898            Error::<T>::NoPermission1899        );19001901        Ok(())1902    }19031904    fn is_owner_or_admin_permissions(collection_id: CollectionId, subject: T::AccountId) -> bool {1905        let target_collection = <Collection<T>>::get(collection_id);1906        let mut result: bool = subject == target_collection.owner;1907        let exists = <AdminList<T>>::contains_key(collection_id);19081909        if !result & exists {1910            if <AdminList<T>>::get(collection_id).contains(&subject) {1911                result = true1912            }1913        }19141915        result1916    }19171918    fn check_owner_or_admin_permissions(1919        collection_id: CollectionId,1920        subject: T::AccountId,1921    ) -> DispatchResult {1922        Self::collection_exists(collection_id)?;1923        let result = Self::is_owner_or_admin_permissions(collection_id, subject.clone());19241925        ensure!(1926            result,1927            Error::<T>::NoPermission1928        );1929        Ok(())1930    }19311932    fn owned_amount(1933        subject: T::AccountId,1934        collection_id: CollectionId,1935        item_id: TokenId,1936    ) -> Option<u128> {1937        let target_collection = <Collection<T>>::get(collection_id);19381939        match target_collection.mode {1940            CollectionMode::NFT => {1941                if <NftItemList<T>>::get(collection_id, item_id).owner == subject {1942                    return Some(1)1943                }1944                None1945            },1946            CollectionMode::Fungible(_) => {1947                if <FungibleItemList<T>>::contains_key(collection_id, &subject) {1948                    return Some(<FungibleItemList<T>>::get(collection_id, &subject)1949                        .value);1950                }1951                None1952            },1953            CollectionMode::ReFungible => <ReFungibleItemList<T>>::get(collection_id, item_id)1954                .owner1955                .iter()1956                .find(|i| i.owner == subject)1957                .map(|i| i.fraction),1958            CollectionMode::Invalid => None,1959        }1960    }19611962    fn is_item_owner(subject: T::AccountId, collection_id: CollectionId, item_id: TokenId) -> bool {1963        let target_collection = <Collection<T>>::get(collection_id);19641965        match target_collection.mode {1966            CollectionMode::NFT => {1967                <NftItemList<T>>::get(collection_id, item_id).owner == subject1968            }1969            CollectionMode::Fungible(_) => {1970                <FungibleItemList<T>>::contains_key(collection_id, &subject)1971            }1972            CollectionMode::ReFungible => {1973                <ReFungibleItemList<T>>::get(collection_id, item_id)1974                    .owner1975                    .iter()1976                    .any(|i| i.owner == subject)1977            }1978            CollectionMode::Invalid => false,1979        }1980    }19811982    fn check_white_list(collection_id: CollectionId, address: &T::AccountId) -> DispatchResult {1983        let mes = Error::<T>::AddresNotInWhiteList;1984        ensure!(<WhiteList<T>>::contains_key(collection_id, address), mes);19851986        Ok(())1987    }19881989    /// Check if token exists. In case of Fungible, check if there is an entry for 1990    /// the owner in fungible balances double map1991    fn token_exists(1992        collection_id: CollectionId,1993        item_id: TokenId,1994        owner: &T::AccountId1995    ) -> DispatchResult {1996        let target_collection = <Collection<T>>::get(collection_id);1997        let exists = match target_collection.mode1998        {1999            CollectionMode::NFT => <NftItemList<T>>::contains_key(collection_id, item_id),2000            CollectionMode::Fungible(_)  => <FungibleItemList<T>>::contains_key(collection_id, owner),2001            CollectionMode::ReFungible  => <ReFungibleItemList<T>>::contains_key(collection_id, item_id),2002            _ => false2003        };20042005        ensure!(exists == true, Error::<T>::TokenNotFound);2006        Ok(())2007    }20082009    fn transfer_fungible(2010        collection_id: CollectionId,2011        value: u128,2012        owner: &T::AccountId,2013        recipient: &T::AccountId,2014    ) -> DispatchResult {2015        Self::token_exists(collection_id, 0, owner)?;20162017        let mut balance = <FungibleItemList<T>>::get(collection_id, owner);2018        ensure!(balance.value >= value, Error::<T>::TokenValueTooLow);20192020        // Send balance to recipient (updates balanceOf of recipient)2021        Self::add_fungible_item(collection_id, recipient, value)?;20222023        // update balanceOf of sender2024        <Balance<T>>::insert(collection_id, (*owner).clone(), balance.value - value);20252026        // Reduce or remove sender2027        if balance.value == value {2028            <FungibleItemList<T>>::remove(collection_id, owner);2029        }2030        else {2031            balance.value -= value;2032            <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), balance);2033        }20342035        Ok(())2036    }20372038    fn transfer_refungible(2039        collection_id: CollectionId,2040        item_id: TokenId,2041        value: u128,2042        owner: T::AccountId,2043        new_owner: T::AccountId,2044    ) -> DispatchResult {2045        Self::token_exists(collection_id, item_id, &owner)?;20462047        let full_item = <ReFungibleItemList<T>>::get(collection_id, item_id);2048        let item = full_item2049            .owner2050            .iter()2051            .filter(|i| i.owner == owner)2052            .next()2053            .ok_or(Error::<T>::NumOverflow)?;2054        let amount = item.fraction;20552056        ensure!(amount >= value, Error::<T>::TokenValueTooLow);20572058        // update balance2059        let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())2060            .checked_sub(value)2061            .ok_or(Error::<T>::NumOverflow)?;2062        <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);20632064        let balancenew_owner = <Balance<T>>::get(collection_id, new_owner.clone())2065            .checked_add(value)2066            .ok_or(Error::<T>::NumOverflow)?;2067        <Balance<T>>::insert(collection_id, new_owner.clone(), balancenew_owner);20682069        let old_owner = item.owner.clone();2070        let new_owner_has_account = full_item.owner.iter().any(|i| i.owner == new_owner);20712072        // transfer2073        if amount == value && !new_owner_has_account {2074            // change owner2075            // new owner do not have account2076            let mut new_full_item = full_item.clone();2077            new_full_item2078                .owner2079                .iter_mut()2080                .find(|i| i.owner == owner)2081                .unwrap()2082                .owner = new_owner.clone();2083            <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);20842085            // update index collection2086            Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;2087        } else {2088            let mut new_full_item = full_item.clone();2089            new_full_item2090                .owner2091                .iter_mut()2092                .find(|i| i.owner == owner)2093                .unwrap()2094                .fraction -= value;20952096            // separate amount2097            if new_owner_has_account {2098                // new owner has account2099                new_full_item2100                    .owner2101                    .iter_mut()2102                    .find(|i| i.owner == new_owner)2103                    .unwrap()2104                    .fraction += value;2105            } else {2106                // new owner do not have account2107                new_full_item.owner.push(Ownership {2108                    owner: new_owner.clone(),2109                    fraction: value,2110                });2111                Self::add_token_index(collection_id, item_id, &new_owner)?;2112            }21132114            <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);2115        }21162117        Ok(())2118    }21192120    fn transfer_nft(2121        collection_id: CollectionId,2122        item_id: TokenId,2123        sender: T::AccountId,2124        new_owner: T::AccountId,2125    ) -> DispatchResult {2126        Self::token_exists(collection_id, item_id, &sender)?;21272128        let mut item = <NftItemList<T>>::get(collection_id, item_id);21292130        ensure!(2131            sender == item.owner,2132            Error::<T>::MustBeTokenOwner2133        );21342135        // update balance2136        let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())2137            .checked_sub(1)2138            .ok_or(Error::<T>::NumOverflow)?;2139        <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);21402141        let balancenew_owner = <Balance<T>>::get(collection_id, new_owner.clone())2142            .checked_add(1)2143            .ok_or(Error::<T>::NumOverflow)?;2144        <Balance<T>>::insert(collection_id, new_owner.clone(), balancenew_owner);21452146        // change owner2147        let old_owner = item.owner.clone();2148        item.owner = new_owner.clone();2149        <NftItemList<T>>::insert(collection_id, item_id, item);21502151        // update index collection2152        Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;21532154        Ok(())2155    }2156    2157    fn set_re_fungible_variable_data(2158        collection_id: CollectionId,2159        item_id: TokenId,2160        data: Vec<u8>2161    ) -> DispatchResult {2162        let mut item = <ReFungibleItemList<T>>::get(collection_id, item_id);21632164        item.variable_data = data;21652166        <ReFungibleItemList<T>>::insert(collection_id, item_id, item);21672168        Ok(())2169    }21702171    fn set_nft_variable_data(2172        collection_id: CollectionId,2173        item_id: TokenId,2174        data: Vec<u8>2175    ) -> DispatchResult {2176        let mut item = <NftItemList<T>>::get(collection_id, item_id);2177        2178        item.variable_data = data;21792180        <NftItemList<T>>::insert(collection_id, item_id, item);2181        2182        Ok(())2183    }21842185    fn init_collection(item: &CollectionType<T::AccountId>) {2186        // check params2187        assert!(2188            item.decimal_points <= MAX_DECIMAL_POINTS,2189            "decimal_points parameter must be lower than MAX_DECIMAL_POINTS"2190        );2191        assert!(2192            item.name.len() <= 64,2193            "Collection name can not be longer than 63 char"2194        );2195        assert!(2196            item.name.len() <= 256,2197            "Collection description can not be longer than 255 char"2198        );2199        assert!(2200            item.token_prefix.len() <= 16,2201            "Token prefix can not be longer than 15 char"2202        );22032204        // Generate next collection ID2205        let next_id = CreatedCollectionCount::get()2206            .checked_add(1)2207            .unwrap();22082209        CreatedCollectionCount::put(next_id);2210    }22112212    fn init_nft_token(collection_id: CollectionId, item: &NftItemType<T::AccountId>) {2213        let current_index = <ItemListIndex>::get(collection_id)2214            .checked_add(1)2215            .unwrap();22162217        let item_owner = item.owner.clone();2218        Self::add_token_index(collection_id, current_index, &item.owner).unwrap();22192220        <ItemListIndex>::insert(collection_id, current_index);22212222        // Update balance2223        let new_balance = <Balance<T>>::get(collection_id, &item_owner)2224            .checked_add(1)2225            .unwrap();2226        <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);2227    }22282229    fn init_fungible_token(collection_id: CollectionId, owner: &T::AccountId, item: &FungibleItemType) {2230        let current_index = <ItemListIndex>::get(collection_id)2231            .checked_add(1)2232            .unwrap();22332234        Self::add_token_index(collection_id, current_index, owner).unwrap();22352236        <ItemListIndex>::insert(collection_id, current_index);22372238        // Update balance2239        let new_balance = <Balance<T>>::get(collection_id, owner)2240            .checked_add(item.value)2241            .unwrap();2242        <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);2243    }22442245    fn init_refungible_token(collection_id: CollectionId, item: &ReFungibleItemType<T::AccountId>) {2246        let current_index = <ItemListIndex>::get(collection_id)2247            .checked_add(1)2248            .unwrap();22492250        let value = item.owner.first().unwrap().fraction;2251        let owner = item.owner.first().unwrap().owner.clone();22522253        Self::add_token_index(collection_id, current_index, &owner).unwrap();22542255        <ItemListIndex>::insert(collection_id, current_index);22562257        // Update balance2258        let new_balance = <Balance<T>>::get(collection_id, &owner)2259            .checked_add(value)2260            .unwrap();2261        <Balance<T>>::insert(collection_id, owner.clone(), new_balance);2262    }22632264    fn add_token_index(collection_id: CollectionId, item_index: TokenId, owner: &T::AccountId) -> DispatchResult {22652266        // add to account limit2267        if <AccountItemCount<T>>::contains_key(owner) {22682269            // bound Owned tokens by a single address2270            let count = <AccountItemCount<T>>::get(owner);2271            ensure!(count < ChainLimit::get().account_token_ownership_limit, Error::<T>::AddressOwnershipLimitExceeded);22722273            <AccountItemCount<T>>::insert(owner.clone(), count2274                .checked_add(1)2275                .ok_or(Error::<T>::NumOverflow)?);2276        }2277        else {2278            <AccountItemCount<T>>::insert(owner.clone(), 1);2279        }22802281        let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner);2282        if list_exists {2283            let mut list = <AddressTokens<T>>::get(collection_id, owner);2284            let item_contains = list.contains(&item_index.clone());22852286            if !item_contains {2287                list.push(item_index.clone());2288            }22892290            <AddressTokens<T>>::insert(collection_id, owner.clone(), list);2291        } else {2292            let mut itm = Vec::new();2293            itm.push(item_index.clone());2294            <AddressTokens<T>>::insert(collection_id, owner.clone(), itm);2295        }22962297        Ok(())2298    }22992300    fn remove_token_index(2301        collection_id: CollectionId,2302        item_index: TokenId,2303        owner: &T::AccountId,2304    ) -> DispatchResult {23052306        // update counter2307        <AccountItemCount<T>>::insert(owner.clone(), 2308            <AccountItemCount<T>>::get(owner)2309            .checked_sub(1)2310            .ok_or(Error::<T>::NumOverflow)?);231123122313        let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner);2314        if list_exists {2315            let mut list = <AddressTokens<T>>::get(collection_id, owner);2316            let item_contains = list.contains(&item_index.clone());23172318            if item_contains {2319                list.retain(|&item| item != item_index);2320                <AddressTokens<T>>::insert(collection_id, owner.clone(), list);2321            }2322        }23232324        Ok(())2325    }23262327    fn move_token_index(2328        collection_id: CollectionId,2329        item_index: TokenId,2330        old_owner: &T::AccountId,2331        new_owner: &T::AccountId,2332    ) -> DispatchResult {2333        Self::remove_token_index(collection_id, item_index, old_owner)?;2334        Self::add_token_index(collection_id, item_index, new_owner)?;23352336        Ok(())2337    }2338    2339    fn ensure_contract_owned(account: T::AccountId, contract: &T::AccountId) -> DispatchResult {2340        if <ContractOwner<T>>::contains_key(contract.clone()) {2341            let owner = <ContractOwner<T>>::get(contract);2342            ensure!(account == owner, Error::<T>::NoPermission);2343        } else {2344            fail!(Error::<T>::NoPermission);2345        }23462347        Ok(())2348    }2349}23502351////////////////////////////////////////////////////////////////////////////////////////////////////2352// Economic models2353// #region23542355/// Fee multiplier.2356pub type Multiplier = FixedU128;23572358type BalanceOf<T> = <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::Balance;23592360/// Require the transactor pay for themselves and maybe include a tip to gain additional priority2361/// in the queue.2362#[derive(Encode, Decode, Clone, Eq, PartialEq)]2363pub struct ChargeTransactionPayment<T: Config>(#[codec(compact)] BalanceOf<T>);23642365impl<T: Config + Send + Sync> sp_std::fmt::Debug 2366    for ChargeTransactionPayment<T>2367{2368	#[cfg(feature = "std")]2369	fn fmt(&self, f: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {2370		write!(f, "ChargeTransactionPayment<{:?}>", self.0)2371	}2372	#[cfg(not(feature = "std"))]2373	fn fmt(&self, _: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {2374		Ok(())2375	}2376}23772378impl<T: Config> ChargeTransactionPayment<T>2379where2380    T::Call: Dispatchable<Info=DispatchInfo, PostInfo=PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,2381    BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,2382    T::AccountId: AsRef<[u8]>,2383    T::AccountId: UncheckedFrom<T::Hash>,2384{2385    fn traditional_fee(2386        len: usize,2387        info: &DispatchInfoOf<T::Call>,2388        tip: BalanceOf<T>,2389    ) -> BalanceOf<T>2390    where2391        T::Call: Dispatchable<Info = DispatchInfo>,2392    {2393        <pallet_transaction_payment::Module<T>>::compute_fee(len as u32, info, tip)2394    }23952396	fn get_priority(len: usize, info: &DispatchInfoOf<T::Call>, final_fee: BalanceOf<T>) -> TransactionPriority {2397        let weight_saturation = T::BlockWeights::get().max_block / info.weight.max(1);2398        let max_block_length = *T::BlockLength::get().max.get(DispatchClass::Normal);2399        let len_saturation = max_block_length as u64 / (len as u64).max(1);2400        let coefficient: BalanceOf<T> = weight_saturation2401            .min(len_saturation)2402            .saturated_into::<BalanceOf<T>>();2403        final_fee2404            .saturating_mul(coefficient)2405            .saturated_into::<TransactionPriority>()2406    }24072408    fn withdraw_fee(2409        &self,2410        who: &T::AccountId,2411        call: &T::Call,2412        info: &DispatchInfoOf<T::Call>,2413        len: usize,2414	) -> Result<2415		(2416			BalanceOf<T>,2417			<<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::LiquidityInfo,2418		),2419		TransactionValidityError,2420	> {2421        let tip = self.0;24222423        // Set fee based on call type. Creating collection costs 1 Unique.2424        // All other transactions have traditional fees so far2425        // let fee = match call.is_sub_type() {2426        //     Some(Call::create_collection(..)) => <BalanceOf<T>>::from(1_000_000_000),2427        //     _ => Self::traditional_fee(len, info, tip), // Flat fee model, use only for testing purposes2428        //                                                 // _ => <BalanceOf<T>>::from(100)2429        // };2430        let fee = Self::traditional_fee(len, info, tip);24312432        // Only mess with balances if fee is not zero.2433        if fee.is_zero() {2434            return <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::withdraw_fee(who, call, info, fee, tip)2435			.map(|i| (fee, i));2436        }24372438        // Determine who is paying transaction fee based on ecnomic model2439        // Parse call to extract collection ID and access collection sponsor2440        let mut sponsor: T::AccountId = match IsSubType::<Call<T>>::is_sub_type(call) {2441            Some(Call::create_item(collection_id, _owner, _properties)) => {24422443                // sponsor timeout2444                let block_number = <system::Module<T>>::block_number() as T::BlockNumber;24452446                let limit = <Collection<T>>::get(collection_id).limits.sponsor_transfer_timeout;2447                let mut sponsored = true;2448                if <CreateItemBasket<T>>::contains_key((collection_id, &who)) {2449                    let last_tx_block = <CreateItemBasket<T>>::get((collection_id, &who));2450                    let limit_time = last_tx_block + limit.into();2451                    if block_number <= limit_time {2452                        sponsored = false;2453                    }2454                }2455                if sponsored {2456                    <CreateItemBasket<T>>::insert((collection_id, who.clone()), block_number);2457                }24582459                // check free create limit2460                if (<Collection<T>>::get(collection_id).limits.sponsored_data_size >= (_properties.len() as u32)) &&2461                   (<Collection<T>>::get(collection_id).sponsor_confirmed) &&2462                   (sponsored)2463                {2464                    <Collection<T>>::get(collection_id).sponsor2465                } else {2466                    T::AccountId::default()2467                }2468            }2469            Some(Call::transfer(_new_owner, collection_id, item_id, _value)) => {2470                2471                let mut sponsor_transfer = false;2472                if <Collection<T>>::get(collection_id).sponsor_confirmed {24732474                    let collection_limits = <Collection<T>>::get(collection_id).limits;2475                    let collection_mode = <Collection<T>>::get(collection_id).mode;2476    2477                    // sponsor timeout2478                    let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2479                    sponsor_transfer = match collection_mode {2480                        CollectionMode::NFT => {2481    2482                            // get correct limit2483                            let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2484                                collection_limits.sponsor_transfer_timeout2485                            } else {2486                                ChainLimit::get().nft_sponsor_transfer_timeout2487                            };2488    2489                            let mut sponsored = true;2490                            if <NftTransferBasket<T>>::contains_key(collection_id, item_id) {2491                                let last_tx_block = <NftTransferBasket<T>>::get(collection_id, item_id);2492                                let limit_time = last_tx_block + limit.into();2493                                if block_number <= limit_time {2494                                    sponsored = false;2495                                }2496                            }2497                            if sponsored {2498                                <NftTransferBasket<T>>::insert(collection_id, item_id, block_number);2499                            }25002501                            sponsored2502                        }2503                        CollectionMode::Fungible(_) => {2504    2505                            // get correct limit2506                            let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2507                                collection_limits.sponsor_transfer_timeout2508                            } else {2509                                ChainLimit::get().fungible_sponsor_transfer_timeout2510                            };2511    2512                            let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2513                            let mut sponsored = true;2514                            if <FungibleTransferBasket<T>>::contains_key(collection_id, who) {2515                                let last_tx_block = <FungibleTransferBasket<T>>::get(collection_id, who);2516                                let limit_time = last_tx_block + limit.into();2517                                if block_number <= limit_time {2518                                    sponsored = false;2519                                }2520                            }2521                            if sponsored {2522                                <FungibleTransferBasket<T>>::insert(collection_id, who, block_number);2523                            }25242525                            sponsored2526                        }2527                        CollectionMode::ReFungible => {2528    2529                            // get correct limit2530                            let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2531                                collection_limits.sponsor_transfer_timeout2532                            } else {2533                                ChainLimit::get().refungible_sponsor_transfer_timeout2534                            };2535    2536                            let mut sponsored = true;2537                            if <ReFungibleTransferBasket<T>>::contains_key(collection_id, item_id) {2538                                let last_tx_block = <ReFungibleTransferBasket<T>>::get(collection_id, item_id);2539                                let limit_time = last_tx_block + limit.into();2540                                if block_number <= limit_time {2541                                    sponsored = false;2542                                }2543                            }2544                            if sponsored {2545                                <ReFungibleTransferBasket<T>>::insert(collection_id, item_id, block_number);2546                            }25472548                            sponsored2549                        }2550                        _ => {2551                            false2552                        },2553                    };2554                }25552556                if !sponsor_transfer {2557                    T::AccountId::default()2558                } else {2559                    <Collection<T>>::get(collection_id).sponsor2560                }2561            }25622563            _ => T::AccountId::default(),2564        };25652566        // Sponsor smart contracts2567        sponsor = match IsSubType::<pallet_contracts::Call<T>>::is_sub_type(call) {25682569            // On instantiation: set the contract owner2570            Some(pallet_contracts::Call::instantiate(_endowment, _gas_limit, code_hash, _data, salt)) => {25712572                let new_contract_address = <pallet_contracts::Module<T>>::contract_address(2573                    &who,2574                    code_hash,2575                    salt,2576                );2577                <ContractOwner<T>>::insert(new_contract_address.clone(), who.clone());25782579                T::AccountId::default()2580            },25812582            // On instantiation with code: set the contract owner2583            Some(pallet_contracts::Call::instantiate_with_code(_endowment, _gas_limit, _code, _data, _salt))  => {25842585                let new_contract_address = <pallet_contracts::Module<T>>::contract_address(2586                    &who,2587                    &T::Hashing::hash(&_code),2588                    _salt,2589                );25902591                <ContractOwner<T>>::insert(new_contract_address.clone(), who.clone());25922593                T::AccountId::default()2594            }25952596            // When the contract is called, check if the sponsoring is enabled and pay fees from contract endowment if it is2597            Some(pallet_contracts::Call::call(dest, _value, _gas_limit, _data)) => {25982599                let called_contract: T::AccountId = T::Lookup::lookup((*dest).clone()).unwrap_or(T::AccountId::default());26002601                let owned_contract = <ContractOwner<T>>::contains_key(called_contract.clone())2602                  && <ContractOwner<T>>::get(called_contract.clone()) == *who;2603                let white_list_enabled = <ContractWhiteListEnabled<T>>::contains_key(called_contract.clone()) && <ContractWhiteListEnabled<T>>::get(called_contract.clone());2604                  2605                if !owned_contract && white_list_enabled {2606                    if !<ContractWhiteList<T>>::contains_key(called_contract.clone(), who) {2607                        return Err(InvalidTransaction::Call.into());2608                    }2609                }26102611                let mut sponsor_transfer = false;2612                if <ContractSponsoringRateLimit<T>>::contains_key(called_contract.clone()) {2613                    let last_tx_block = <ContractSponsorBasket<T>>::get((&called_contract, &who));2614                    let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2615                    let rate_limit = <ContractSponsoringRateLimit<T>>::get(&called_contract);2616                    let limit_time = last_tx_block + rate_limit;26172618                    if block_number >= limit_time {2619                        <ContractSponsorBasket<T>>::insert((called_contract.clone(), who.clone()), block_number);2620                        sponsor_transfer = true;2621                    }2622                } else {2623                    sponsor_transfer = false;2624                }2625               2626                2627                let mut sp = T::AccountId::default();2628                if sponsor_transfer {2629                    if <ContractSelfSponsoring<T>>::contains_key(called_contract.clone()) {2630                        if <ContractSelfSponsoring<T>>::get(called_contract.clone()) {2631                            sp = called_contract;2632                        }2633                    }2634                }26352636                sp2637            },26382639            _ => sponsor,2640        };26412642        let mut who_pays_fee: T::AccountId = sponsor.clone();2643        if sponsor == T::AccountId::default() {2644            who_pays_fee = who.clone();2645        }26462647		<<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::withdraw_fee(&who_pays_fee, call, info, fee, tip)2648			.map(|i| (fee, i))2649    }2650}265126522653impl<T: Config + Send + Sync> SignedExtension2654    for ChargeTransactionPayment<T>2655where2656    BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,2657    T::Call: Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,2658    T::AccountId: AsRef<[u8]>,2659    T::AccountId: UncheckedFrom<T::Hash>,2660{2661    const IDENTIFIER: &'static str = "ChargeTransactionPayment";2662    type AccountId = T::AccountId;2663    type Call = T::Call;2664    type AdditionalSigned = ();2665    type Pre = (2666        // tip2667        BalanceOf<T>,2668        // who pays fee2669        Self::AccountId,2670		// imbalance resulting from withdrawing the fee2671		<<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::LiquidityInfo,2672    );2673    fn additional_signed(&self) -> sp_std::result::Result<(), TransactionValidityError> {2674        Ok(())2675    }26762677    fn validate(2678        &self,2679        who: &Self::AccountId,2680        call: &Self::Call,2681        info: &DispatchInfoOf<Self::Call>,2682        len: usize,2683    ) -> TransactionValidity {2684		let (fee, _) = self.withdraw_fee(who, call, info, len)?;2685		Ok(ValidTransaction {2686			priority: Self::get_priority(len, info, fee),2687			..Default::default()2688		})2689    }26902691    fn pre_dispatch(2692        self,2693        who: &Self::AccountId,2694        call: &Self::Call,2695        info: &DispatchInfoOf<Self::Call>,2696        len: usize,2697    ) -> Result<Self::Pre, TransactionValidityError> {2698        let (_fee, imbalance) = self.withdraw_fee(who, call, info, len)?;2699        Ok((self.0, who.clone(), imbalance))2700    }27012702    fn post_dispatch(2703        pre: Self::Pre,2704        info: &DispatchInfoOf<Self::Call>,2705        post_info: &PostDispatchInfoOf<Self::Call>,2706        len: usize,2707        _result: &DispatchResult,2708    ) -> Result<(), TransactionValidityError> {2709		let (tip, who, imbalance) = pre;2710		let actual_fee = pallet_transaction_payment::Module::<T>::compute_actual_fee(2711			len as u32,2712			info,2713			post_info,2714			tip,2715		);2716		<T as pallet_transaction_payment::Config>::OnChargeTransaction::correct_and_deposit_fee(&who, info, post_info, actual_fee, tip, imbalance)?;2717		Ok(())2718    }2719}27202721// #endregion