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

1//2// This file is subject to the terms and conditions defined in3// file 'LICENSE', which is part of this source code package.4//56#![recursion_limit = "1024"]78#![cfg_attr(not(feature = "std"), no_std)]910#[cfg(feature = "std")]11pub use std::*;1213#[cfg(feature = "std")]14pub use serde::*;1516use codec::{Decode, Encode};17pub use frame_support::{18    construct_runtime, decl_event, decl_module, decl_storage, decl_error,19    dispatch::DispatchResult,20    ensure, fail, parameter_types,21    traits::{22        Currency, ExistenceRequirement, Get, Imbalance, KeyOwnerProofSystem, OnUnbalanced,23        Randomness, IsSubType,24    },25    weights::{26        constants::{BlockExecutionWeight, ExtrinsicBaseWeight, RocksDbWeight, WEIGHT_PER_SECOND},27        DispatchInfo, GetDispatchInfo, IdentityFee, Pays, PostDispatchInfo, Weight,28        WeightToFeePolynomial, DispatchClass,29    },30    StorageValue,31};3233use frame_system::{self as system, ensure_signed, ensure_root};34use sp_runtime::sp_std::prelude::Vec;35use sp_runtime::{36    traits::{37        DispatchInfoOf, Dispatchable, PostDispatchInfoOf, Saturating, SaturatedConversion, SignedExtension, Zero,38    },39    transaction_validity::{40        TransactionPriority, InvalidTransaction, TransactionValidity, TransactionValidityError, ValidTransaction,41    },42    FixedPointOperand, FixedU128,43};44use sp_runtime::traits::StaticLookup;45use pallet_contracts::chain_extension::UncheckedFrom;46use transaction_payment::OnChargeTransaction;4748#[cfg(test)]49mod mock;5051#[cfg(test)]52mod tests;5354mod default_weights;5556pub const MAX_DECIMAL_POINTS: DecimalPoints = 30;57pub const MAX_REFUNGIBLE_PIECES: u128 = 1_000_000_000_000_000_000_000;58pub const MAX_SPONSOR_TIMEOUT: u32 = 10_368_000;59pub const MAX_TOKEN_OWNERSHIP: u32 = 10_000_000;6061// Structs62// #region6364pub type CollectionId = u32;65pub type TokenId = u32;66pub type DecimalPoints = u8;6768#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq)]69#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]70pub enum CollectionMode {71    Invalid,72    NFT,73    // decimal points74    Fungible(DecimalPoints),75    ReFungible,76}7778impl Default for CollectionMode {79    fn default() -> Self {80        Self::Invalid81    }82}8384impl Into<u8> for CollectionMode {85    fn into(self) -> u8 {86        match self {87            CollectionMode::Invalid => 0,88            CollectionMode::NFT => 1,89            CollectionMode::Fungible(_) => 2,90            CollectionMode::ReFungible => 3,91        }92    }93}9495#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq)]96#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]97pub enum AccessMode {98    Normal,99    WhiteList,100}101impl Default for AccessMode {102    fn default() -> Self {103        Self::Normal104    }105}106107#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq)]108#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]109pub enum SchemaVersion {110    ImageURL,111    Unique,112}113impl Default for SchemaVersion {114    fn default() -> Self {115        Self::ImageURL116    }117}118119#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]120#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]121pub struct Ownership<AccountId> {122    pub owner: AccountId,123    pub fraction: u128,124}125126#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]127#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]128pub struct CollectionType<AccountId> {129    pub owner: AccountId,130    pub mode: CollectionMode,131    pub access: AccessMode,132    pub decimal_points: DecimalPoints,133    pub name: Vec<u16>,        // 64 include null escape char134    pub description: Vec<u16>, // 256 include null escape char135    pub token_prefix: Vec<u8>, // 16 include null escape char136    pub mint_mode: bool,137    pub offchain_schema: Vec<u8>,138    pub schema_version: SchemaVersion,139    pub sponsor: AccountId, // Who pays fees. If set to default address, the fees are applied to the transaction sender140    pub sponsor_confirmed: bool, // False if sponsor address has not yet confirmed sponsorship. True otherwise.141    pub limits: CollectionLimits, // Collection private restrictions 142    pub variable_on_chain_schema: Vec<u8>, //143    pub const_on_chain_schema: Vec<u8>, //144}145146#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]147#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]148pub struct NftItemType<AccountId> {149    pub owner: AccountId,150    pub const_data: Vec<u8>,151    pub variable_data: Vec<u8>,152}153154#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]155#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]156pub struct FungibleItemType {157    pub value: u128,158}159160#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]161#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]162pub struct ReFungibleItemType<AccountId> {163    pub owner: Vec<Ownership<AccountId>>,164    pub const_data: Vec<u8>,165    pub variable_data: Vec<u8>,166}167168// #[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]169// #[cfg_attr(feature = "std", derive(Serialize, Deserialize))]170// pub struct VestingItem<AccountId, Moment> {171//     pub sender: AccountId,172//     pub recipient: AccountId,173//     pub collection_id: CollectionId,174//     pub item_id: TokenId,175//     pub amount: u64,176//     pub vesting_date: Moment,177// }178179#[derive(Encode, Decode, Debug, Clone, PartialEq)]180#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]181pub struct CollectionLimits {182    pub account_token_ownership_limit: u32,183    pub sponsored_data_size: u32,184    pub token_limit: u32,185186    // Timeouts for item types in passed blocks187    pub sponsor_transfer_timeout: u32,188    pub owner_can_transfer: bool,189    pub owner_can_destroy: bool,190}191192impl Default for CollectionLimits {193    fn default() -> CollectionLimits {194        CollectionLimits { 195            account_token_ownership_limit: 10_000_000, 196            token_limit: u32::max_value(),197            sponsored_data_size: u32::max_value(), 198            sponsor_transfer_timeout: 14400,199            owner_can_transfer: true,200            owner_can_destroy: true201        }202    }203}204205#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]206#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]207pub struct ChainLimits {208    pub collection_numbers_limit: u32,209    pub account_token_ownership_limit: u32,210    pub collections_admins_limit: u64,211    pub custom_data_limit: u32,212213    // Timeouts for item types in passed blocks214    pub nft_sponsor_transfer_timeout: u32,215    pub fungible_sponsor_transfer_timeout: u32,216    pub refungible_sponsor_transfer_timeout: u32,217218    // Schema limits219    pub offchain_schema_limit: u32,220    pub variable_on_chain_schema_limit: u32,221    pub const_on_chain_schema_limit: u32,222}223224pub trait WeightInfo {225	fn create_collection() -> Weight;226	fn destroy_collection() -> Weight;227	fn add_to_white_list() -> Weight;228	fn remove_from_white_list() -> Weight;229    fn set_public_access_mode() -> Weight;230    fn set_mint_permission() -> Weight;231    fn change_collection_owner() -> Weight;232    fn add_collection_admin() -> Weight;233    fn remove_collection_admin() -> Weight;234    fn set_collection_sponsor() -> Weight;235    fn confirm_sponsorship() -> Weight;236    fn remove_collection_sponsor() -> Weight;237    fn create_item(s: usize) -> Weight;238    fn burn_item() -> Weight;239    fn transfer() -> Weight;240    fn approve() -> Weight;241    fn transfer_from() -> Weight;242    fn set_offchain_schema() -> Weight;243    fn set_const_on_chain_schema() -> Weight;244    fn set_variable_on_chain_schema() -> Weight;245    fn set_variable_meta_data() -> Weight;246    fn enable_contract_sponsoring() -> Weight;247    fn set_schema_version() -> Weight;248    fn set_chain_limits() -> Weight;249    fn set_contract_sponsoring_rate_limit() -> Weight;250    fn toggle_contract_white_list() -> Weight;251    fn add_to_contract_white_list() -> Weight;252    fn remove_from_contract_white_list() -> Weight;253    fn set_collection_limits() -> Weight;254}255256#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]257#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]258pub struct CreateNftData {259    pub const_data: Vec<u8>,260    pub variable_data: Vec<u8>,261}262263#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]264#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]265pub struct CreateFungibleData {266    pub value: u128,267}268269#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]270#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]271pub struct CreateReFungibleData {272    pub const_data: Vec<u8>,273    pub variable_data: Vec<u8>,274    pub pieces: u128,275}276277#[derive(Encode, Decode, Debug, Clone, PartialEq)]278#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]279pub enum CreateItemData {280    NFT(CreateNftData),281    Fungible(CreateFungibleData),282    ReFungible(CreateReFungibleData),283}284285impl CreateItemData {286    pub fn len(&self) -> usize {287        let len = match self {288            CreateItemData::NFT(data) => data.variable_data.len() + data.const_data.len(),289            CreateItemData::ReFungible(data) => data.variable_data.len() + data.const_data.len(),290            _ => 0291        };292        293        return len;294    }295}296297impl From<CreateNftData> for CreateItemData {298    fn from(item: CreateNftData) -> Self {299        CreateItemData::NFT(item)300    }301}302303impl From<CreateReFungibleData> for CreateItemData {304    fn from(item: CreateReFungibleData) -> Self {305        CreateItemData::ReFungible(item)306    }307}308309impl From<CreateFungibleData> for CreateItemData {310    fn from(item: CreateFungibleData) -> Self {311        CreateItemData::Fungible(item)312    }313}314315316decl_error! {317	/// Error for non-fungible-token module.318	pub enum Error for Module<T: Config> {319        /// Total collections bound exceeded.320        TotalCollectionsLimitExceeded,321		/// Decimal_points parameter must be lower than MAX_DECIMAL_POINTS constant, currently it is 30.322        CollectionDecimalPointLimitExceeded, 323        /// Collection name can not be longer than 63 char.324        CollectionNameLimitExceeded, 325        /// Collection description can not be longer than 255 char.326        CollectionDescriptionLimitExceeded, 327        /// Token prefix can not be longer than 15 char.328        CollectionTokenPrefixLimitExceeded,329        /// This collection does not exist.330        CollectionNotFound,331        /// Item not exists.332        TokenNotFound,333        /// Admin not found334        AdminNotFound,335        /// Arithmetic calculation overflow.336        NumOverflow,       337        /// Account already has admin role.338        AlreadyAdmin,  339        /// You do not own this collection.340        NoPermission,341        /// This address is not set as sponsor, use setCollectionSponsor first.342        ConfirmUnsetSponsorFail,343        /// Collection is not in mint mode.344        PublicMintingNotAllowed,345        /// Sender parameter and item owner must be equal.346        MustBeTokenOwner,347        /// Item balance not enough.348        TokenValueTooLow,349        /// Size of item is too large.350        NftSizeLimitExceeded,351        /// No approve found352        ApproveNotFound,353        /// Requested value more than approved.354        TokenValueNotEnough,355        /// Only approved addresses can call this method.356        ApproveRequired,357        /// Address is not in white list.358        AddresNotInWhiteList,359        /// Number of collection admins bound exceeded.360        CollectionAdminsLimitExceeded,361        /// Owned tokens by a single address bound exceeded.362        AddressOwnershipLimitExceeded,363        /// Length of items properties must be greater than 0.364        EmptyArgument,365        /// const_data exceeded data limit.366        TokenConstDataLimitExceeded,367        /// variable_data exceeded data limit.368        TokenVariableDataLimitExceeded,369        /// Not NFT item data used to mint in NFT collection.370        NotNftDataUsedToMintNftCollectionToken,371        /// Not Fungible item data used to mint in Fungible collection.372        NotFungibleDataUsedToMintFungibleCollectionToken,373        /// Not Re Fungible item data used to mint in Re Fungible collection.374        NotReFungibleDataUsedToMintReFungibleCollectionToken,375        /// Unexpected collection type.376        UnexpectedCollectionType,377        /// Can't store metadata in fungible tokens.378        CantStoreMetadataInFungibleTokens,379        /// Collection token limit exceeded380        CollectionTokenLimitExceeded,381        /// Account token limit exceeded per collection382        AccountTokenLimitExceeded,383        /// Collection limit bounds per collection exceeded384        CollectionLimitBoundsExceeded,385        /// Schema data size limit bound exceeded386        SchemaDataLimitExceeded,387        /// Maximum refungibility exceeded388        WrongRefungiblePieces389	}390}391392pub trait Config: system::Config + Sized + transaction_payment::Config + pallet_contracts::Config {393    type Event: From<Event<Self>> + Into<<Self as system::Config>::Event>;394395    /// Weight information for extrinsics in this pallet.396	type WeightInfo: WeightInfo;397}398399#[cfg(feature = "runtime-benchmarks")]400mod benchmarking;401402// #endregion403404decl_storage! {405    trait Store for Module<T: Config> as Nft {406407        // Private members408        NextCollectionID: CollectionId;409        CreatedCollectionCount: u32;410        ChainVersion: u64;411        ItemListIndex: map hasher(identity) CollectionId => TokenId;412413        // Chain limits struct414        pub ChainLimit get(fn chain_limit) config(): ChainLimits;415416        // Bound counters417        CollectionCount: u32;418        pub AccountItemCount get(fn account_item_count): map hasher(twox_64_concat) T::AccountId => u32;419420        // Basic collections421        pub Collection get(fn collection) config(): map hasher(identity) CollectionId => CollectionType<T::AccountId>;422        pub AdminList get(fn admin_list_collection): map hasher(identity) CollectionId => Vec<T::AccountId>;423        pub WhiteList get(fn white_list): double_map hasher(identity) CollectionId, hasher(twox_64_concat) T::AccountId => bool;424425        /// Balance owner per collection map426        pub Balance get(fn balance_count): double_map hasher(identity) CollectionId, hasher(twox_64_concat) T::AccountId => u128;427428        /// second parameter: item id + owner account id + spender account id429        pub Allowances get(fn approved): double_map hasher(identity) CollectionId, hasher(twox_64_concat) (TokenId, T::AccountId, T::AccountId) => u128;430431        /// Item collections432        pub NftItemList get(fn nft_item_id) config(): double_map hasher(identity) CollectionId, hasher(identity) TokenId => NftItemType<T::AccountId>;433        pub FungibleItemList get(fn fungible_item_id) config(): double_map hasher(identity) CollectionId, hasher(twox_64_concat) T::AccountId => FungibleItemType;434        pub ReFungibleItemList get(fn refungible_item_id) config(): double_map hasher(identity) CollectionId, hasher(identity) TokenId => ReFungibleItemType<T::AccountId>;435436        /// Index list437        pub AddressTokens get(fn address_tokens): double_map hasher(identity) CollectionId, hasher(twox_64_concat) T::AccountId => Vec<TokenId>;438439        /// Tokens transfer baskets440        pub CreateItemBasket get(fn create_item_basket): map hasher(twox_64_concat) (CollectionId, T::AccountId) => T::BlockNumber;441        pub NftTransferBasket get(fn nft_transfer_basket): double_map hasher(identity) CollectionId, hasher(identity) TokenId => T::BlockNumber;442        pub FungibleTransferBasket get(fn fungible_transfer_basket): double_map hasher(identity) CollectionId, hasher(twox_64_concat) T::AccountId => T::BlockNumber;443        pub ReFungibleTransferBasket get(fn refungible_transfer_basket): double_map hasher(identity) CollectionId, hasher(identity) TokenId => T::BlockNumber;444445        // Contract Sponsorship and Ownership446        pub ContractOwner get(fn contract_owner): map hasher(twox_64_concat) T::AccountId => T::AccountId;447        pub ContractSelfSponsoring get(fn contract_self_sponsoring): map hasher(twox_64_concat) T::AccountId => bool;448        pub ContractSponsorBasket get(fn contract_sponsor_basket): map hasher(twox_64_concat) (T::AccountId, T::AccountId) => T::BlockNumber;449        pub ContractSponsoringRateLimit get(fn contract_sponsoring_rate_limit): map hasher(twox_64_concat) T::AccountId => T::BlockNumber;450        pub ContractWhiteListEnabled get(fn contract_white_list_enabled): map hasher(twox_64_concat) T::AccountId => bool; 451        pub ContractWhiteList get(fn contract_white_list): double_map hasher(twox_64_concat) T::AccountId, hasher(twox_64_concat) T::AccountId => bool; 452    }453    add_extra_genesis {454        build(|config: &GenesisConfig<T>| {455            // Modification of storage456            for (_num, _c) in &config.collection {457                <Module<T>>::init_collection(_c);458            }459460            for (_num, _c, _i) in &config.nft_item_id {461                <Module<T>>::init_nft_token(*_c, _i);462            }463464            for (collection_id, account_id, fungible_item) in &config.fungible_item_id {465                <Module<T>>::init_fungible_token(*collection_id, account_id, fungible_item);466            }467468            for (_num, _c, _i) in &config.refungible_item_id {469                <Module<T>>::init_refungible_token(*_c, _i);470            }471        })472    }473}474475decl_event!(476    pub enum Event<T>477    where478        AccountId = <T as system::Config>::AccountId,479    {480        /// New collection was created481        /// 482        /// # Arguments483        /// 484        /// * collection_id: Globally unique identifier of newly created collection.485        /// 486        /// * mode: [CollectionMode] converted into u8.487        /// 488        /// * account_id: Collection owner.489        Created(CollectionId, u8, AccountId),490491        /// New item was created.492        /// 493        /// # Arguments494        /// 495        /// * collection_id: Id of the collection where item was created.496        /// 497        /// * item_id: Id of an item. Unique within the collection.498        ///499        /// * recipient: Owner of newly created item 500        ItemCreated(CollectionId, TokenId, AccountId),501502        /// Collection item was burned.503        /// 504        /// # Arguments505        /// 506        /// collection_id.507        /// 508        /// item_id: Identifier of burned NFT.509        ItemDestroyed(CollectionId, TokenId),510511        /// Item was transferred512        ///513        /// * collection_id: Id of collection to which item is belong514        ///515        /// * item_id: Id of an item516        ///517        /// * sender: Original owner of item518        ///519        /// * recipient: New owner of item520        ///521        /// * amount: Always 1 for NFT522        Transfer(CollectionId, TokenId, AccountId, AccountId, u128),523    }524);525526decl_module! {527    pub struct Module<T: Config> for enum Call 528    where 529        origin: T::Origin530    {531        fn deposit_event() = default;532        type Error = Error<T>;533534        fn on_initialize(now: T::BlockNumber) -> Weight {535536            if ChainVersion::get() < 2537            {538                let value = NextCollectionID::get();539                CreatedCollectionCount::put(value);540                ChainVersion::put(2);541            }542543            0544        }545546        /// 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.547        /// 548        /// # Permissions549        /// 550        /// * Anyone.551        /// 552        /// # Arguments553        /// 554        /// * collection_name: UTF-16 string with collection name (limit 64 characters), will be stored as zero-terminated.555        /// 556        /// * collection_description: UTF-16 string with collection description (limit 256 characters), will be stored as zero-terminated.557        /// 558        /// * token_prefix: UTF-8 string with token prefix.559        /// 560        /// * mode: [CollectionMode] collection type and type dependent data.561        // returns collection ID562        #[weight = <T as Config>::WeightInfo::create_collection()]563        pub fn create_collection(origin,564                                 collection_name: Vec<u16>,565                                 collection_description: Vec<u16>,566                                 token_prefix: Vec<u8>,567                                 mode: CollectionMode) -> DispatchResult {568569            // Anyone can create a collection570            let who = ensure_signed(origin)?;571572            let decimal_points = match mode {573                CollectionMode::Fungible(points) => points,574                _ => 0575            };576577            // bound Total number of collections578            ensure!(CollectionCount::get() < ChainLimit::get().collection_numbers_limit, Error::<T>::TotalCollectionsLimitExceeded);579580            // check params581            ensure!(decimal_points <= MAX_DECIMAL_POINTS, Error::<T>::CollectionDecimalPointLimitExceeded);582            ensure!(collection_name.len() <= 64, Error::<T>::CollectionNameLimitExceeded);583            ensure!(collection_description.len() <= 256, Error::<T>::CollectionDescriptionLimitExceeded);584            ensure!(token_prefix.len() <= 16, Error::<T>::CollectionTokenPrefixLimitExceeded);585586            // Generate next collection ID587            let next_id = CreatedCollectionCount::get()588                .checked_add(1)589                .ok_or(Error::<T>::NumOverflow)?;590591            // bound counter592            let total = CollectionCount::get()593                .checked_add(1)594                .ok_or(Error::<T>::NumOverflow)?;595596            CreatedCollectionCount::put(next_id);597            CollectionCount::put(total);598599            // Create new collection600            let new_collection = CollectionType {601                owner: who.clone(),602                name: collection_name,603                mode: mode.clone(),604                mint_mode: false,605                access: AccessMode::Normal,606                description: collection_description,607                decimal_points: decimal_points,608                token_prefix: token_prefix,609                offchain_schema: Vec::new(),610                schema_version: SchemaVersion::ImageURL,611                sponsor: T::AccountId::default(),612                sponsor_confirmed: false,613                variable_on_chain_schema: Vec::new(),614                const_on_chain_schema: Vec::new(),615                limits: CollectionLimits::default()616            };617618            // Add new collection to map619            <Collection<T>>::insert(next_id, new_collection);620621            // call event622            Self::deposit_event(RawEvent::Created(next_id, mode.into(), who.clone()));623624            Ok(())625        }626627        /// **DANGEROUS**: Destroys collection and all NFTs within this collection. Users irrecoverably lose their assets and may lose real money.628        /// 629        /// # Permissions630        /// 631        /// * Collection Owner.632        /// 633        /// # Arguments634        /// 635        /// * collection_id: collection to destroy.636        #[weight = <T as Config>::WeightInfo::destroy_collection()]637        pub fn destroy_collection(origin, collection_id: CollectionId) -> DispatchResult {638639            let sender = ensure_signed(origin)?;640            Self::check_owner_permissions(collection_id, sender)?;641642            <AddressTokens<T>>::remove_prefix(collection_id);643            <Allowances<T>>::remove_prefix(collection_id);644            <Balance<T>>::remove_prefix(collection_id);645            <ItemListIndex>::remove(collection_id);646            <AdminList<T>>::remove(collection_id);647            <Collection<T>>::remove(collection_id);648            <WhiteList<T>>::remove_prefix(collection_id);649650            <NftItemList<T>>::remove_prefix(collection_id);651            <FungibleItemList<T>>::remove_prefix(collection_id);652            <ReFungibleItemList<T>>::remove_prefix(collection_id);653654            <NftTransferBasket<T>>::remove_prefix(collection_id);655            <FungibleTransferBasket<T>>::remove_prefix(collection_id);656            <ReFungibleTransferBasket<T>>::remove_prefix(collection_id);657658            if CollectionCount::get() > 0659            {660                // bound couter661                let total = CollectionCount::get()662                    .checked_sub(1)663                    .ok_or(Error::<T>::NumOverflow)?;664665                CollectionCount::put(total);666            }667668            Ok(())669        }670671        /// Add an address to white list.672        /// 673        /// # Permissions674        /// 675        /// * Collection Owner676        /// * Collection Admin677        /// 678        /// # Arguments679        /// 680        /// * collection_id.681        /// 682        /// * address.683        #[weight = <T as Config>::WeightInfo::add_to_white_list()]684        pub fn add_to_white_list(origin, collection_id: CollectionId, address: T::AccountId) -> DispatchResult{685686            let sender = ensure_signed(origin)?;687            Self::check_owner_or_admin_permissions(collection_id, sender)?;688689            <WhiteList<T>>::insert(collection_id, address, true);690            691            Ok(())692        }693694        /// Remove an address from white list.695        /// 696        /// # Permissions697        /// 698        /// * Collection Owner699        /// * Collection Admin700        /// 701        /// # Arguments702        /// 703        /// * collection_id.704        /// 705        /// * address.706        #[weight = <T as Config>::WeightInfo::remove_from_white_list()]707        pub fn remove_from_white_list(origin, collection_id: CollectionId, address: T::AccountId) -> DispatchResult{708709            let sender = ensure_signed(origin)?;710            Self::check_owner_or_admin_permissions(collection_id, sender)?;711712            <WhiteList<T>>::remove(collection_id, address);713714            Ok(())715        }716717        /// Toggle between normal and white list access for the methods with access for `Anyone`.718        /// 719        /// # Permissions720        /// 721        /// * Collection Owner.722        /// 723        /// # Arguments724        /// 725        /// * collection_id.726        /// 727        /// * mode: [AccessMode]728        #[weight = <T as Config>::WeightInfo::set_public_access_mode()]729        pub fn set_public_access_mode(origin, collection_id: CollectionId, mode: AccessMode) -> DispatchResult730        {731            let sender = ensure_signed(origin)?;732733            Self::check_owner_permissions(collection_id, sender)?;734            let mut target_collection = <Collection<T>>::get(collection_id);735            target_collection.access = mode;736            <Collection<T>>::insert(collection_id, target_collection);737738            Ok(())739        }740741        /// Allows Anyone to create tokens if:742        /// * White List is enabled, and743        /// * Address is added to white list, and744        /// * This method was called with True parameter745        /// 746        /// # Permissions747        /// * Collection Owner748        ///749        /// # Arguments750        /// 751        /// * collection_id.752        /// 753        /// * mint_permission: Boolean parameter. If True, allows minting to Anyone with conditions above.754        #[weight = <T as Config>::WeightInfo::set_mint_permission()]755        pub fn set_mint_permission(origin, collection_id: CollectionId, mint_permission: bool) -> DispatchResult756        {757            let sender = ensure_signed(origin)?;758759            Self::check_owner_permissions(collection_id, sender)?;760            let mut target_collection = <Collection<T>>::get(collection_id);761            target_collection.mint_mode = mint_permission;762            <Collection<T>>::insert(collection_id, target_collection);763764            Ok(())765        }766767        /// Change the owner of the collection.768        /// 769        /// # Permissions770        /// 771        /// * Collection Owner.772        /// 773        /// # Arguments774        /// 775        /// * collection_id.776        /// 777        /// * new_owner.778        #[weight = <T as Config>::WeightInfo::change_collection_owner()]779        pub fn change_collection_owner(origin, collection_id: CollectionId, new_owner: T::AccountId) -> DispatchResult {780781            let sender = ensure_signed(origin)?;782            Self::check_owner_permissions(collection_id, sender)?;783            let mut target_collection = <Collection<T>>::get(collection_id);784            target_collection.owner = new_owner;785            <Collection<T>>::insert(collection_id, target_collection);786787            Ok(())788        }789790        /// Adds an admin of the Collection.791        /// 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. 792        /// 793        /// # Permissions794        /// 795        /// * Collection Owner.796        /// * Collection Admin.797        /// 798        /// # Arguments799        /// 800        /// * collection_id: ID of the Collection to add admin for.801        /// 802        /// * new_admin_id: Address of new admin to add.803        #[weight = <T as Config>::WeightInfo::add_collection_admin()]804        pub fn add_collection_admin(origin, collection_id: CollectionId, new_admin_id: T::AccountId) -> DispatchResult {805806            let sender = ensure_signed(origin)?;807            Self::check_owner_or_admin_permissions(collection_id, sender)?;808            let mut admin_arr: Vec<T::AccountId> = Vec::new();809810            if <AdminList<T>>::contains_key(collection_id)811            {812                admin_arr = <AdminList<T>>::get(collection_id);813                ensure!(!admin_arr.contains(&new_admin_id), Error::<T>::AlreadyAdmin);814            }815816            // Number of collection admins817            ensure!((admin_arr.len() as u64) < ChainLimit::get().collections_admins_limit, Error::<T>::CollectionAdminsLimitExceeded);818819            admin_arr.push(new_admin_id);820            <AdminList<T>>::insert(collection_id, admin_arr);821822            Ok(())823        }824825        /// 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.826        ///827        /// # Permissions828        /// 829        /// * Collection Owner.830        /// * Collection Admin.831        /// 832        /// # Arguments833        /// 834        /// * collection_id: ID of the Collection to remove admin for.835        /// 836        /// * account_id: Address of admin to remove.837        #[weight = <T as Config>::WeightInfo::remove_collection_admin()]838        pub fn remove_collection_admin(origin, collection_id: CollectionId, account_id: T::AccountId) -> DispatchResult {839840            let sender = ensure_signed(origin)?;841            Self::check_owner_or_admin_permissions(collection_id, sender)?;842            ensure!(<AdminList<T>>::contains_key(collection_id), Error::<T>::AdminNotFound);843844            let mut admin_arr = <AdminList<T>>::get(collection_id);845            admin_arr.retain(|i| *i != account_id);846            <AdminList<T>>::insert(collection_id, admin_arr);847848            Ok(())849        }850851        /// # Permissions852        /// 853        /// * Collection Owner854        /// 855        /// # Arguments856        /// 857        /// * collection_id.858        /// 859        /// * new_sponsor.860        #[weight = <T as Config>::WeightInfo::set_collection_sponsor()]861        pub fn set_collection_sponsor(origin, collection_id: CollectionId, new_sponsor: T::AccountId) -> DispatchResult {862863            let sender = ensure_signed(origin)?;864            ensure!(<Collection<T>>::contains_key(collection_id), Error::<T>::CollectionNotFound);865866            let mut target_collection = <Collection<T>>::get(collection_id);867            ensure!(sender == target_collection.owner, Error::<T>::NoPermission);868869            target_collection.sponsor = new_sponsor;870            target_collection.sponsor_confirmed = false;871            <Collection<T>>::insert(collection_id, target_collection);872873            Ok(())874        }875876        /// # Permissions877        /// 878        /// * Sponsor.879        /// 880        /// # Arguments881        /// 882        /// * collection_id.883        #[weight = <T as Config>::WeightInfo::confirm_sponsorship()]884        pub fn confirm_sponsorship(origin, collection_id: CollectionId) -> DispatchResult {885886            let sender = ensure_signed(origin)?;887            ensure!(<Collection<T>>::contains_key(collection_id), Error::<T>::CollectionNotFound);888889            let mut target_collection = <Collection<T>>::get(collection_id);890            ensure!(sender == target_collection.sponsor, Error::<T>::ConfirmUnsetSponsorFail);891892            target_collection.sponsor_confirmed = true;893            <Collection<T>>::insert(collection_id, target_collection);894895            Ok(())896        }897898        /// Switch back to pay-per-own-transaction model.899        ///900        /// # Permissions901        ///902        /// * Collection owner.903        /// 904        /// # Arguments905        /// 906        /// * collection_id.907        #[weight = <T as Config>::WeightInfo::remove_collection_sponsor()]908        pub fn remove_collection_sponsor(origin, collection_id: CollectionId) -> DispatchResult {909910            let sender = ensure_signed(origin)?;911            ensure!(<Collection<T>>::contains_key(collection_id), Error::<T>::CollectionNotFound);912913            let mut target_collection = <Collection<T>>::get(collection_id);914            ensure!(sender == target_collection.owner, Error::<T>::NoPermission);915916            target_collection.sponsor = T::AccountId::default();917            target_collection.sponsor_confirmed = false;918            <Collection<T>>::insert(collection_id, target_collection);919920            Ok(())921        }922923        /// This method creates a concrete instance of NFT Collection created with CreateCollection method.924        /// 925        /// # Permissions926        /// 927        /// * Collection Owner.928        /// * Collection Admin.929        /// * Anyone if930        ///     * White List is enabled, and931        ///     * Address is added to white list, and932        ///     * MintPermission is enabled (see SetMintPermission method)933        /// 934        /// # Arguments935        /// 936        /// * collection_id: ID of the collection.937        /// 938        /// * owner: Address, initial owner of the NFT.939        ///940        /// * data: Token data to store on chain.941        // #[weight =942        // (130_000_000 as Weight)943        // .saturating_add((2135 as Weight).saturating_mul((properties.len() as u64) as Weight))944        // .saturating_add(RocksDbWeight::get().reads(10 as Weight))945        // .saturating_add(RocksDbWeight::get().writes(8 as Weight))]946947        #[weight = <T as Config>::WeightInfo::create_item(data.len())]948        pub fn create_item(origin, collection_id: CollectionId, owner: T::AccountId, data: CreateItemData) -> DispatchResult {949950            let sender = ensure_signed(origin)?;951952            Self::collection_exists(collection_id)?;953954            let target_collection = <Collection<T>>::get(collection_id);955956            Self::can_create_items_in_collection(collection_id, &target_collection, &sender, &owner)?;957            Self::validate_create_item_args(&target_collection, &data)?;958            Self::create_item_no_validation(collection_id, owner, data)?;959960            Ok(())961        }962963        /// This method creates multiple instances of NFT Collection created with CreateCollection method.964        /// 965        /// # Permissions966        /// 967        /// * Collection Owner.968        /// * Collection Admin.969        /// * Anyone if970        ///     * White List is enabled, and971        ///     * Address is added to white list, and972        ///     * MintPermission is enabled (see SetMintPermission method)973        /// 974        /// # Arguments975        /// 976        /// * collection_id: ID of the collection.977        /// 978        /// * itemsData: Array items properties. Each property is an array of bytes itself, see [create_item].979        /// 980        /// * owner: Address, initial owner of the NFT.981        #[weight = <T as Config>::WeightInfo::create_item(items_data.into_iter()982                               .map(|data| { data.len() })983                               .sum())]984        pub fn create_multiple_items(origin, collection_id: CollectionId, owner: T::AccountId, items_data: Vec<CreateItemData>) -> DispatchResult {985986            ensure!(items_data.len() > 0, Error::<T>::EmptyArgument);987            let sender = ensure_signed(origin)?;988989            Self::collection_exists(collection_id)?;990            let target_collection = <Collection<T>>::get(collection_id);991992            Self::can_create_items_in_collection(collection_id, &target_collection, &sender, &owner)?;993994            for data in &items_data {995                Self::validate_create_item_args(&target_collection, data)?;996            }997            for data in &items_data {998                Self::create_item_no_validation(collection_id, owner.clone(), data.clone())?;999            }10001001            Ok(())1002        }10031004        /// Destroys a concrete instance of NFT.1005        /// 1006        /// # Permissions1007        /// 1008        /// * Collection Owner.1009        /// * Collection Admin.1010        /// * Current NFT Owner.1011        /// 1012        /// # Arguments1013        /// 1014        /// * collection_id: ID of the collection.1015        /// 1016        /// * item_id: ID of NFT to burn.1017        #[weight = <T as Config>::WeightInfo::burn_item()]1018        pub fn burn_item(origin, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {10191020            let sender = ensure_signed(origin)?;1021            Self::collection_exists(collection_id)?;10221023            // Transfer permissions check1024            let target_collection = <Collection<T>>::get(collection_id);1025            ensure!(Self::is_item_owner(sender.clone(), collection_id, item_id) ||1026                Self::is_owner_or_admin_permissions(collection_id, sender.clone()),1027                Error::<T>::NoPermission);10281029            if target_collection.access == AccessMode::WhiteList {1030                Self::check_white_list(collection_id, &sender)?;1031            }10321033            match target_collection.mode1034            {1035                CollectionMode::NFT => Self::burn_nft_item(collection_id, item_id)?,1036                CollectionMode::Fungible(_)  => Self::burn_fungible_item(&sender, collection_id, value)?,1037                CollectionMode::ReFungible  => Self::burn_refungible_item(collection_id, item_id, &sender)?,1038                _ => ()1039            };10401041            // call event1042            Self::deposit_event(RawEvent::ItemDestroyed(collection_id, item_id));10431044            Ok(())1045        }10461047        /// Change ownership of the token.1048        /// 1049        /// # Permissions1050        /// 1051        /// * Collection Owner1052        /// * Collection Admin1053        /// * Current NFT owner1054        ///1055        /// # Arguments1056        /// 1057        /// * recipient: Address of token recipient.1058        /// 1059        /// * collection_id.1060        /// 1061        /// * item_id: ID of the item1062        ///     * Non-Fungible Mode: Required.1063        ///     * Fungible Mode: Ignored.1064        ///     * Re-Fungible Mode: Required.1065        /// 1066        /// * value: Amount to transfer.1067        ///     * Non-Fungible Mode: Ignored1068        ///     * Fungible Mode: Must specify transferred amount1069        ///     * Re-Fungible Mode: Must specify transferred portion (between 0 and 1)1070        #[weight = <T as Config>::WeightInfo::transfer()]1071        pub fn transfer(origin, recipient: T::AccountId, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {1072            let sender = ensure_signed(origin)?;1073            Self::transfer_internal(sender, recipient, collection_id, item_id, value)1074        }10751076        /// Set, change, or remove approved address to transfer the ownership of the NFT.1077        /// 1078        /// # Permissions1079        /// 1080        /// * Collection Owner1081        /// * Collection Admin1082        /// * Current NFT owner1083        /// 1084        /// # Arguments1085        /// 1086        /// * approved: Address that is approved to transfer this NFT or zero (if needed to remove approval).1087        /// 1088        /// * collection_id.1089        /// 1090        /// * item_id: ID of the item.1091        #[weight = <T as Config>::WeightInfo::approve()]1092        pub fn approve(origin, spender: T::AccountId, collection_id: CollectionId, item_id: TokenId, amount: u128) -> DispatchResult {10931094            let sender = ensure_signed(origin)?;10951096            Self::collection_exists(collection_id)?;1097            Self::token_exists(collection_id, item_id, &sender)?;10981099            // Transfer permissions check1100            let target_collection = <Collection<T>>::get(collection_id);1101            let allowance_limit = if Self::is_owner_or_admin_permissions(1102                collection_id,1103                sender.clone(),1104            ) {1105                None1106            } else if let Some(amount) = Self::owned_amount(1107                sender.clone(),1108                collection_id,1109                item_id,1110            ) {1111                Some(amount)1112            } else {1113                fail!(Error::<T>::NoPermission);1114            };11151116            if target_collection.access == AccessMode::WhiteList {1117                Self::check_white_list(collection_id, &sender)?;1118                Self::check_white_list(collection_id, &spender)?;1119            }11201121            let allowance_exists = <Allowances<T>>::contains_key(collection_id, (item_id, &sender, &spender));1122            let mut allowance: u128 = amount;1123            if allowance_exists {1124                allowance += <Allowances<T>>::get(collection_id, (item_id, &sender, &spender));1125            }1126            if let Some(limit) = allowance_limit {1127                ensure!(limit >= allowance, Error::<T>::TokenValueTooLow);1128            }1129            <Allowances<T>>::insert(collection_id, (item_id, sender.clone(), spender.clone()), allowance);11301131            Ok(())1132        }1133        1134        /// 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.1135        /// 1136        /// # Permissions1137        /// * Collection Owner1138        /// * Collection Admin1139        /// * Current NFT owner1140        /// * Address approved by current NFT owner1141        /// 1142        /// # Arguments1143        /// 1144        /// * from: Address that owns token.1145        /// 1146        /// * recipient: Address of token recipient.1147        /// 1148        /// * collection_id.1149        /// 1150        /// * item_id: ID of the item.1151        /// 1152        /// * value: Amount to transfer.1153        #[weight = <T as Config>::WeightInfo::transfer_from()]1154        pub fn transfer_from(origin, from: T::AccountId, recipient: T::AccountId, collection_id: CollectionId, item_id: TokenId, value: u128 ) -> DispatchResult {11551156            let sender = ensure_signed(origin)?;1157            let mut appoved_transfer = false;11581159            // Check approval1160            let mut approval: u128 = 0;1161            if <Allowances<T>>::contains_key(collection_id, (item_id, &from, &sender)) {1162                approval = <Allowances<T>>::get(collection_id, (item_id, &from, &sender));1163                ensure!(approval >= value, Error::<T>::TokenValueNotEnough);1164                appoved_transfer = true;1165            }11661167            let target_collection = <Collection<T>>::get(collection_id);11681169            // Limits check1170            Self::is_correct_transfer(collection_id, &target_collection, &recipient)?;11711172            // Transfer permissions check         1173            ensure!(appoved_transfer || Self::is_owner_or_admin_permissions(collection_id, sender.clone()),1174                Error::<T>::NoPermission);11751176            if target_collection.access == AccessMode::WhiteList {1177                Self::check_white_list(collection_id, &sender)?;1178                Self::check_white_list(collection_id, &recipient)?;1179            }11801181            // Reduce approval by transferred amount or remove if remaining approval drops to 01182            if approval.checked_sub(value).unwrap_or(0) > 0 {1183                <Allowances<T>>::insert(collection_id, (item_id, &from, &sender), approval - value);1184            }1185            else {1186                <Allowances<T>>::remove(collection_id, (item_id, &from, &sender));1187            }11881189            match target_collection.mode1190            {1191                CollectionMode::NFT => Self::transfer_nft(collection_id, item_id, from, recipient)?,1192                CollectionMode::Fungible(_)  => Self::transfer_fungible(collection_id, value, &from, &recipient)?,1193                CollectionMode::ReFungible  => Self::transfer_refungible(collection_id, item_id, value, from.clone(), recipient)?,1194                _ => ()1195            };11961197            Ok(())1198        }11991200        // #[weight = 0]1201        // pub fn safe_transfer_from(origin, collection_id: CollectionId, item_id: TokenId, new_owner: T::AccountId) -> DispatchResult {12021203        //     // let no_perm_mes = "You do not have permissions to modify this collection";1204        //     // ensure!(<ApprovedList<T>>::contains_key((collection_id, item_id)), no_perm_mes);1205        //     // let list_itm = <ApprovedList<T>>::get((collection_id, item_id));1206        //     // ensure!(list_itm.contains(&new_owner.clone()), no_perm_mes);12071208        //     // // on_nft_received  call12091210        //     // Self::transfer(origin, collection_id, item_id, new_owner)?;12111212        //     Ok(())1213        // }12141215        /// Set off-chain data schema.1216        /// 1217        /// # Permissions1218        /// 1219        /// * Collection Owner1220        /// * Collection Admin1221        /// 1222        /// # Arguments1223        /// 1224        /// * collection_id.1225        /// 1226        /// * schema: String representing the offchain data schema.1227        #[weight = <T as Config>::WeightInfo::set_variable_meta_data()]1228        pub fn set_variable_meta_data (1229            origin,1230            collection_id: CollectionId,1231            item_id: TokenId,1232            data: Vec<u8>1233        ) -> DispatchResult {1234            let sender = ensure_signed(origin)?;1235            1236            Self::collection_exists(collection_id)?;1237            Self::token_exists(collection_id, item_id, &sender)?;12381239            ensure!(ChainLimit::get().custom_data_limit >= data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);12401241            // Modify permissions check1242            let target_collection = <Collection<T>>::get(collection_id);1243            ensure!(Self::is_item_owner(sender.clone(), collection_id, item_id) ||1244                Self::is_owner_or_admin_permissions(collection_id, sender.clone()),1245                Error::<T>::NoPermission);12461247            match target_collection.mode1248            {1249                CollectionMode::NFT => Self::set_nft_variable_data(collection_id, item_id, data)?,1250                CollectionMode::ReFungible  => Self::set_re_fungible_variable_data(collection_id, item_id, data)?,1251                CollectionMode::Fungible(_) => fail!(Error::<T>::CantStoreMetadataInFungibleTokens),1252                _ => fail!(Error::<T>::UnexpectedCollectionType)1253            };12541255            Ok(())1256        }1257 1258        /// Set schema standard1259        /// ImageURL1260        /// Unique1261        /// 1262        /// # Permissions1263        /// 1264        /// * Collection Owner1265        /// * Collection Admin1266        /// 1267        /// # Arguments1268        /// 1269        /// * collection_id.1270        /// 1271        /// * schema: SchemaVersion: enum1272        #[weight = <T as Config>::WeightInfo::set_schema_version()]1273        pub fn set_schema_version(1274            origin,1275            collection_id: CollectionId,1276            version: SchemaVersion1277        ) -> DispatchResult {1278            let sender = ensure_signed(origin)?;1279            Self::check_owner_or_admin_permissions(collection_id, sender.clone())?;1280            let mut target_collection = <Collection<T>>::get(collection_id);1281            target_collection.schema_version = version;1282            <Collection<T>>::insert(collection_id, target_collection);12831284            Ok(())1285        }12861287        /// Set off-chain data schema.1288        /// 1289        /// # Permissions1290        /// 1291        /// * Collection Owner1292        /// * Collection Admin1293        /// 1294        /// # Arguments1295        /// 1296        /// * collection_id.1297        /// 1298        /// * schema: String representing the offchain data schema.1299        #[weight = <T as Config>::WeightInfo::set_offchain_schema()]1300        pub fn set_offchain_schema(1301            origin,1302            collection_id: CollectionId,1303            schema: Vec<u8>1304        ) -> DispatchResult {1305            let sender = ensure_signed(origin)?;1306            Self::check_owner_or_admin_permissions(collection_id, sender.clone())?;13071308            // check schema limit1309            ensure!(schema.len() as u32 <= ChainLimit::get().offchain_schema_limit, "");13101311            let mut target_collection = <Collection<T>>::get(collection_id);1312            target_collection.offchain_schema = schema;1313            <Collection<T>>::insert(collection_id, target_collection);13141315            Ok(())1316        }13171318        /// Set const on-chain data schema.1319        /// 1320        /// # Permissions1321        /// 1322        /// * Collection Owner1323        /// * Collection Admin1324        /// 1325        /// # Arguments1326        /// 1327        /// * collection_id.1328        /// 1329        /// * schema: String representing the const on-chain data schema.1330        #[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1331        pub fn set_const_on_chain_schema (1332            origin,1333            collection_id: CollectionId,1334            schema: Vec<u8>1335        ) -> DispatchResult {1336            let sender = ensure_signed(origin)?;1337            Self::check_owner_or_admin_permissions(collection_id, sender.clone())?;13381339            // check schema limit1340            ensure!(schema.len() as u32 <= ChainLimit::get().const_on_chain_schema_limit, "");13411342            let mut target_collection = <Collection<T>>::get(collection_id);1343            target_collection.const_on_chain_schema = schema;1344            <Collection<T>>::insert(collection_id, target_collection);13451346            Ok(())1347        }13481349        /// Set variable on-chain data schema.1350        /// 1351        /// # Permissions1352        /// 1353        /// * Collection Owner1354        /// * Collection Admin1355        /// 1356        /// # Arguments1357        /// 1358        /// * collection_id.1359        /// 1360        /// * schema: String representing the variable on-chain data schema.1361        #[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1362        pub fn set_variable_on_chain_schema (1363            origin,1364            collection_id: CollectionId,1365            schema: Vec<u8>1366        ) -> DispatchResult {1367            let sender = ensure_signed(origin)?;1368            Self::check_owner_or_admin_permissions(collection_id, sender.clone())?;13691370            // check schema limit1371            ensure!(schema.len() as u32 <= ChainLimit::get().variable_on_chain_schema_limit, "");13721373            let mut target_collection = <Collection<T>>::get(collection_id);1374            target_collection.variable_on_chain_schema = schema;1375            <Collection<T>>::insert(collection_id, target_collection);13761377            Ok(())1378        }13791380        // Sudo permissions function1381        #[weight = <T as Config>::WeightInfo::set_chain_limits()]1382        pub fn set_chain_limits(1383            origin,1384            limits: ChainLimits1385        ) -> DispatchResult {13861387            #[cfg(not(feature = "runtime-benchmarks"))]1388            ensure_root(origin)?;13891390            <ChainLimit>::put(limits);1391            Ok(())1392        }13931394        /// Enable smart contract self-sponsoring.1395        /// 1396        /// # Permissions1397        /// 1398        /// * Contract Owner1399        /// 1400        /// # Arguments1401        /// 1402        /// * contract address1403        /// * enable flag1404        /// 1405        #[weight = <T as Config>::WeightInfo::enable_contract_sponsoring()]1406        pub fn enable_contract_sponsoring(1407            origin,1408            contract_address: T::AccountId,1409            enable: bool1410        ) -> DispatchResult {14111412            let sender = ensure_signed(origin)?;14131414            #[cfg(feature = "runtime-benchmarks")]1415            <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());14161417            Self::ensure_contract_owned(sender, &contract_address)?;14181419            <ContractSelfSponsoring<T>>::insert(contract_address, enable);1420            Ok(())1421        }14221423        /// Set the rate limit for contract sponsoring to specified number of blocks.1424        /// 1425        /// If not set (has the default value of 0 blocks), the sponsoring will be disabled. 1426        /// If set to the number B (for blocks), the transactions will be sponsored with a rate 1427        /// limit of B, i.e. fees for every transaction sent to this smart contract will be paid 1428        /// from contract endowment if there are at least B blocks between such transactions. 1429        /// Nonetheless, if transactions are sent more frequently, the fees are paid by the sender.1430        /// 1431        /// # Permissions1432        /// 1433        /// * Contract Owner1434        /// 1435        /// # Arguments1436        /// 1437        /// -`contract_address`: Address of the contract to sponsor1438        /// -`rate_limit`: Number of blocks to wait until the next sponsored transaction is allowed1439        /// 1440        #[weight = <T as Config>::WeightInfo::set_contract_sponsoring_rate_limit()]1441        pub fn set_contract_sponsoring_rate_limit(1442            origin,1443            contract_address: T::AccountId,1444            rate_limit: T::BlockNumber1445        ) -> DispatchResult {1446            let sender = ensure_signed(origin)?;14471448            #[cfg(feature = "runtime-benchmarks")]1449            <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());14501451            Self::ensure_contract_owned(sender, &contract_address)?;1452            <ContractSponsoringRateLimit<T>>::insert(contract_address, rate_limit);1453            Ok(())1454        }14551456        /// Enable the white list for a contract. Only addresses added to the white list with addToContractWhiteList will be able to call this smart contract.1457        /// 1458        /// # Permissions1459        /// 1460        /// * Address that deployed smart contract.1461        /// 1462        /// # Arguments1463        /// 1464        /// -`contract_address`: Address of the contract.1465        /// 1466        /// - `enable`: .  1467        #[weight = <T as Config>::WeightInfo::toggle_contract_white_list()]1468        pub fn toggle_contract_white_list(1469            origin,1470            contract_address: T::AccountId,1471            enable: bool1472        ) -> DispatchResult {1473            let sender = ensure_signed(origin)?;14741475            #[cfg(feature = "runtime-benchmarks")]1476            <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());14771478            Self::ensure_contract_owned(sender, &contract_address)?;1479            <ContractWhiteListEnabled<T>>::insert(contract_address, enable);1480            Ok(())1481        }1482        1483        /// Add an address to smart contract white list.1484        /// 1485        /// # Permissions1486        /// 1487        /// * Address that deployed smart contract.1488        /// 1489        /// # Arguments1490        /// 1491        /// -`contract_address`: Address of the contract.1492        ///1493        /// -`account_address`: Address to add.1494        #[weight = <T as Config>::WeightInfo::add_to_contract_white_list()]1495        pub fn add_to_contract_white_list(1496            origin,1497            contract_address: T::AccountId,1498            account_address: T::AccountId1499        ) -> DispatchResult {1500            let sender = ensure_signed(origin)?;15011502            #[cfg(feature = "runtime-benchmarks")]1503            <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());1504            1505            Self::ensure_contract_owned(sender, &contract_address)?;      1506            <ContractWhiteList<T>>::insert(contract_address, account_address, true);1507            Ok(())1508        }15091510        /// Remove an address from smart contract white list.1511        /// 1512        /// # Permissions1513        /// 1514        /// * Address that deployed smart contract.1515        /// 1516        /// # Arguments1517        /// 1518        /// -`contract_address`: Address of the contract.1519        ///1520        /// -`account_address`: Address to remove.1521        #[weight = <T as Config>::WeightInfo::remove_from_contract_white_list()]1522        pub fn remove_from_contract_white_list(1523            origin,1524            contract_address: T::AccountId,1525            account_address: T::AccountId1526        ) -> DispatchResult {1527            let sender = ensure_signed(origin)?;15281529            #[cfg(feature = "runtime-benchmarks")]1530            <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());15311532            Self::ensure_contract_owned(sender, &contract_address)?;1533            <ContractWhiteList<T>>::remove(contract_address, account_address);1534            Ok(())1535        }15361537        #[weight = <T as Config>::WeightInfo::set_collection_limits()]1538        pub fn set_collection_limits(1539            origin,1540            collection_id: u32,1541            limits: CollectionLimits,1542        ) -> DispatchResult {1543            let sender = ensure_signed(origin)?;1544            Self::check_owner_permissions(collection_id, sender.clone())?;1545            let mut target_collection = <Collection<T>>::get(collection_id);1546            let chain_limits = ChainLimit::get();1547            let climits = target_collection.limits;15481549            // collection bounds1550            ensure!(limits.sponsor_transfer_timeout <= MAX_SPONSOR_TIMEOUT &&1551                limits.account_token_ownership_limit <= MAX_TOKEN_OWNERSHIP,  1552                Error::<T>::CollectionLimitBoundsExceeded);15531554            // token_limit   check  prev1555            ensure!(climits.token_limit > limits.token_limit && 1556                limits.token_limit <= chain_limits.account_token_ownership_limit, 1557                Error::<T>::AccountTokenLimitExceeded);15581559            target_collection.limits = limits;1560            <Collection<T>>::insert(collection_id, target_collection);15611562            Ok(())1563        } 1564    }1565}15661567impl<T: Config> Module<T> {15681569    pub fn transfer_internal(sender: T::AccountId, recipient: T::AccountId, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {15701571        let target_collection = <Collection<T>>::get(collection_id);15721573        // Limits check1574        Self::is_correct_transfer(collection_id, &target_collection, &recipient)?;15751576        // Transfer permissions check1577        ensure!(Self::is_item_owner(sender.clone(), collection_id, item_id) ||1578            Self::is_owner_or_admin_permissions(collection_id, sender.clone()),1579            Error::<T>::NoPermission);15801581        if target_collection.access == AccessMode::WhiteList {1582            Self::check_white_list(collection_id, &sender)?;1583            Self::check_white_list(collection_id, &recipient)?;1584        }15851586        match target_collection.mode1587        {1588            CollectionMode::NFT => Self::transfer_nft(collection_id, item_id, sender.clone(), recipient.clone())?,1589            CollectionMode::Fungible(_)  => Self::transfer_fungible(collection_id, value, &sender, &recipient)?,1590            CollectionMode::ReFungible  => Self::transfer_refungible(collection_id, item_id, value, sender.clone(), recipient.clone())?,1591            _ => ()1592        };15931594        Self::deposit_event(RawEvent::Transfer(collection_id, item_id, sender, recipient, value));15951596        Ok(())1597    }159815991600    fn is_correct_transfer(collection_id: CollectionId, collection: &CollectionType<T::AccountId>, recipient: &T::AccountId) -> DispatchResult {16011602        // check token limit and account token limit1603        let account_items: u32 = <AddressTokens<T>>::get(collection_id, recipient).len() as u32;1604        ensure!(collection.limits.account_token_ownership_limit > account_items,  Error::<T>::AccountTokenLimitExceeded);1605        1606        Ok(())1607    }16081609    fn can_create_items_in_collection(collection_id: CollectionId, collection: &CollectionType<T::AccountId>, sender: &T::AccountId, owner: &T::AccountId) -> DispatchResult {16101611        // check token limit and account token limit1612        let total_items: u32 = ItemListIndex::get(collection_id);1613        let account_items: u32 = <AddressTokens<T>>::get(collection_id, owner).len() as u32;1614        ensure!(collection.limits.token_limit > total_items,  Error::<T>::CollectionTokenLimitExceeded);1615        ensure!(collection.limits.account_token_ownership_limit > account_items,  Error::<T>::AccountTokenLimitExceeded);16161617        if !Self::is_owner_or_admin_permissions(collection_id, sender.clone()) {1618            ensure!(collection.mint_mode == true, Error::<T>::PublicMintingNotAllowed);1619            Self::check_white_list(collection_id, owner)?;1620            Self::check_white_list(collection_id, sender)?;1621        }16221623        Ok(())1624    }16251626    fn validate_create_item_args(target_collection: &CollectionType<T::AccountId>, data: &CreateItemData) -> DispatchResult {1627        match target_collection.mode1628        {1629            CollectionMode::NFT => {1630                if let CreateItemData::NFT(data) = data {1631                    // check sizes1632                    ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, Error::<T>::TokenConstDataLimitExceeded);1633                    ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);1634                } else {1635                    fail!(Error::<T>::NotNftDataUsedToMintNftCollectionToken);1636                }1637            },1638            CollectionMode::Fungible(_) => {1639                if let CreateItemData::Fungible(_) = data {1640                } else {1641                    fail!(Error::<T>::NotFungibleDataUsedToMintFungibleCollectionToken);1642                }1643            },1644            CollectionMode::ReFungible => {1645                if let CreateItemData::ReFungible(data) = data {16461647                    // check sizes1648                    ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, Error::<T>::TokenConstDataLimitExceeded);1649                    ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);16501651                    // Check refungibility limits1652                    ensure!(data.pieces <= MAX_REFUNGIBLE_PIECES, Error::<T>::WrongRefungiblePieces);1653                    ensure!(data.pieces > 0, Error::<T>::WrongRefungiblePieces);1654                } else {1655                    fail!(Error::<T>::NotReFungibleDataUsedToMintReFungibleCollectionToken);1656                }1657            },1658            _ => { fail!(Error::<T>::UnexpectedCollectionType); }1659        };16601661        Ok(())1662    }16631664    fn create_item_no_validation(collection_id: CollectionId, owner: T::AccountId, data: CreateItemData) -> DispatchResult {1665        match data1666        {1667            CreateItemData::NFT(data) => {1668                let item = NftItemType {1669                    owner: owner.clone(),1670                    const_data: data.const_data,1671                    variable_data: data.variable_data1672                };16731674                Self::add_nft_item(collection_id, item)?;1675            },1676            CreateItemData::Fungible(data) => {1677                Self::add_fungible_item(collection_id, &owner, data.value)?;1678            },1679            CreateItemData::ReFungible(data) => {1680                let mut owner_list = Vec::new();1681                owner_list.push(Ownership {owner: owner.clone(), fraction: data.pieces});16821683                let item = ReFungibleItemType {1684                    owner: owner_list,1685                    const_data: data.const_data,1686                    variable_data: data.variable_data1687                };16881689                Self::add_refungible_item(collection_id, item)?;1690            }1691        };16921693        // call event1694        Self::deposit_event(RawEvent::ItemCreated(collection_id, <ItemListIndex>::get(collection_id), owner));16951696        Ok(())1697    }16981699    fn add_fungible_item(collection_id: CollectionId, owner: &T::AccountId, value: u128) -> DispatchResult {17001701        // Does new owner already have an account?1702        let mut balance: u128 = 0;1703        if <FungibleItemList<T>>::contains_key(collection_id, owner) {1704            balance = <FungibleItemList<T>>::get(collection_id, owner).value;1705        } 17061707        // Mint 1708        let item = FungibleItemType {1709            value: balance + value1710        };1711        <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), item);17121713        // Update balance1714        let new_balance = <Balance<T>>::get(collection_id, owner)1715            .checked_add(value)1716            .ok_or(Error::<T>::NumOverflow)?;1717        <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);17181719        Ok(())1720    }17211722    fn add_refungible_item(collection_id: CollectionId, item: ReFungibleItemType<T::AccountId>) -> DispatchResult {1723        let current_index = <ItemListIndex>::get(collection_id)1724            .checked_add(1)1725            .ok_or(Error::<T>::NumOverflow)?;1726        let itemcopy = item.clone();17271728        let value = item.owner.first().unwrap().fraction;1729        let owner = item.owner.first().unwrap().owner.clone();17301731        Self::add_token_index(collection_id, current_index, &owner)?;17321733        <ItemListIndex>::insert(collection_id, current_index);1734        <ReFungibleItemList<T>>::insert(collection_id, current_index, itemcopy);17351736        // Update balance1737        let new_balance = <Balance<T>>::get(collection_id, &owner)1738            .checked_add(value)1739            .ok_or(Error::<T>::NumOverflow)?;1740        <Balance<T>>::insert(collection_id, owner.clone(), new_balance);17411742        Ok(())1743    }17441745    fn add_nft_item(collection_id: CollectionId, item: NftItemType<T::AccountId>) -> DispatchResult {1746        let current_index = <ItemListIndex>::get(collection_id)1747            .checked_add(1)1748            .ok_or(Error::<T>::NumOverflow)?;17491750        let item_owner = item.owner.clone();1751        Self::add_token_index(collection_id, current_index, &item.owner)?;17521753        <ItemListIndex>::insert(collection_id, current_index);1754        <NftItemList<T>>::insert(collection_id, current_index, item);17551756        // Update balance1757        let new_balance = <Balance<T>>::get(collection_id, item_owner.clone())1758            .checked_add(1)1759            .ok_or(Error::<T>::NumOverflow)?;1760        <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);17611762        Ok(())1763    }17641765    fn burn_refungible_item(1766        collection_id: CollectionId,1767        item_id: TokenId,1768        owner: &T::AccountId,1769    ) -> DispatchResult {1770        ensure!(1771            <ReFungibleItemList<T>>::contains_key(collection_id, item_id),1772            Error::<T>::TokenNotFound1773        );1774        let mut token = <ReFungibleItemList<T>>::get(collection_id, item_id);1775        let rft_balance = token1776            .owner1777            .iter()1778            .filter(|&i| i.owner == *owner)1779            .next()1780            .unwrap();1781        Self::remove_token_index(collection_id, item_id, owner)?;17821783        // update balance1784        let new_balance = <Balance<T>>::get(collection_id, rft_balance.owner.clone())1785            .checked_sub(rft_balance.fraction)1786            .ok_or(Error::<T>::NumOverflow)?;1787        <Balance<T>>::insert(collection_id, rft_balance.owner.clone(), new_balance);17881789        // Re-create owners list with sender removed1790        let index = token1791            .owner1792            .iter()1793            .position(|i| i.owner == *owner)1794            .unwrap();1795        token.owner.remove(index);1796        let owner_count = token.owner.len();17971798        // Burn the token completely if this was the last (only) owner1799        if owner_count == 0 {1800            <ReFungibleItemList<T>>::remove(collection_id, item_id);1801        }1802        else {1803            <ReFungibleItemList<T>>::insert(collection_id, item_id, token);1804        }18051806        Ok(())1807    }18081809    fn burn_nft_item(collection_id: CollectionId, item_id: TokenId) -> DispatchResult {1810        ensure!(1811            <NftItemList<T>>::contains_key(collection_id, item_id),1812            Error::<T>::TokenNotFound1813        );1814        let item = <NftItemList<T>>::get(collection_id, item_id);1815        Self::remove_token_index(collection_id, item_id, &item.owner)?;18161817        // update balance1818        let new_balance = <Balance<T>>::get(collection_id, &item.owner)1819            .checked_sub(1)1820            .ok_or(Error::<T>::NumOverflow)?;1821        <Balance<T>>::insert(collection_id, item.owner.clone(), new_balance);1822        <NftItemList<T>>::remove(collection_id, item_id);18231824        Ok(())1825    }18261827    fn burn_fungible_item(owner: &T::AccountId, collection_id: CollectionId, value: u128) -> DispatchResult {1828        ensure!(1829            <FungibleItemList<T>>::contains_key(collection_id, owner),1830            Error::<T>::TokenNotFound1831        );1832        let mut balance = <FungibleItemList<T>>::get(collection_id, owner);1833        ensure!(balance.value >= value, Error::<T>::TokenValueNotEnough);18341835        // update balance1836        let new_balance = <Balance<T>>::get(collection_id, owner)1837            .checked_sub(value)1838            .ok_or(Error::<T>::NumOverflow)?;1839        <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);18401841        if balance.value - value > 0 {1842            balance.value -= value;1843            <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), balance);1844        }1845        else {1846            <FungibleItemList<T>>::remove(collection_id, owner);1847        }18481849        Ok(())1850    }18511852    fn collection_exists(collection_id: CollectionId) -> DispatchResult {1853        ensure!(1854            <Collection<T>>::contains_key(collection_id),1855            Error::<T>::CollectionNotFound1856        );1857        Ok(())1858    }18591860    fn check_owner_permissions(collection_id: CollectionId, subject: T::AccountId) -> DispatchResult {1861        Self::collection_exists(collection_id)?;18621863        let target_collection = <Collection<T>>::get(collection_id);1864        ensure!(1865            subject == target_collection.owner,1866            Error::<T>::NoPermission1867        );18681869        Ok(())1870    }18711872    fn is_owner_or_admin_permissions(collection_id: CollectionId, subject: T::AccountId) -> bool {1873        let target_collection = <Collection<T>>::get(collection_id);1874        let mut result: bool = subject == target_collection.owner;1875        let exists = <AdminList<T>>::contains_key(collection_id);18761877        if !result & exists {1878            if <AdminList<T>>::get(collection_id).contains(&subject) {1879                result = true1880            }1881        }18821883        result1884    }18851886    fn check_owner_or_admin_permissions(1887        collection_id: CollectionId,1888        subject: T::AccountId,1889    ) -> DispatchResult {1890        Self::collection_exists(collection_id)?;1891        let result = Self::is_owner_or_admin_permissions(collection_id, subject.clone());18921893        ensure!(1894            result,1895            Error::<T>::NoPermission1896        );1897        Ok(())1898    }18991900    fn owned_amount(1901        subject: T::AccountId,1902        collection_id: CollectionId,1903        item_id: TokenId,1904    ) -> Option<u128> {1905        let target_collection = <Collection<T>>::get(collection_id);19061907        match target_collection.mode {1908            CollectionMode::NFT => {1909                if <NftItemList<T>>::get(collection_id, item_id).owner == subject {1910                    return Some(1)1911                }1912                None1913            },1914            CollectionMode::Fungible(_) => {1915                if <FungibleItemList<T>>::contains_key(collection_id, &subject) {1916                    return Some(<FungibleItemList<T>>::get(collection_id, &subject)1917                        .value);1918                }1919                None1920            },1921            CollectionMode::ReFungible => <ReFungibleItemList<T>>::get(collection_id, item_id)1922                .owner1923                .iter()1924                .find(|i| i.owner == subject)1925                .map(|i| i.fraction),1926            CollectionMode::Invalid => None,1927        }1928    }19291930    fn is_item_owner(subject: T::AccountId, collection_id: CollectionId, item_id: TokenId) -> bool {1931        let target_collection = <Collection<T>>::get(collection_id);19321933        match target_collection.mode {1934            CollectionMode::NFT => {1935                <NftItemList<T>>::get(collection_id, item_id).owner == subject1936            }1937            CollectionMode::Fungible(_) => {1938                <FungibleItemList<T>>::contains_key(collection_id, &subject)1939            }1940            CollectionMode::ReFungible => {1941                <ReFungibleItemList<T>>::get(collection_id, item_id)1942                    .owner1943                    .iter()1944                    .any(|i| i.owner == subject)1945            }1946            CollectionMode::Invalid => false,1947        }1948    }19491950    fn check_white_list(collection_id: CollectionId, address: &T::AccountId) -> DispatchResult {1951        let mes = Error::<T>::AddresNotInWhiteList;1952        ensure!(<WhiteList<T>>::contains_key(collection_id, address), mes);19531954        Ok(())1955    }19561957    /// Check if token exists. In case of Fungible, check if there is an entry for 1958    /// the owner in fungible balances double map1959    fn token_exists(1960        collection_id: CollectionId,1961        item_id: TokenId,1962        owner: &T::AccountId1963    ) -> DispatchResult {1964        let target_collection = <Collection<T>>::get(collection_id);1965        let exists = match target_collection.mode1966        {1967            CollectionMode::NFT => <NftItemList<T>>::contains_key(collection_id, item_id),1968            CollectionMode::Fungible(_)  => <FungibleItemList<T>>::contains_key(collection_id, owner),1969            CollectionMode::ReFungible  => <ReFungibleItemList<T>>::contains_key(collection_id, item_id),1970            _ => false1971        };19721973        ensure!(exists == true, Error::<T>::TokenNotFound);1974        Ok(())1975    }19761977    fn transfer_fungible(1978        collection_id: CollectionId,1979        value: u128,1980        owner: &T::AccountId,1981        recipient: &T::AccountId,1982    ) -> DispatchResult {1983        Self::token_exists(collection_id, 0, owner)?;19841985        let mut balance = <FungibleItemList<T>>::get(collection_id, owner);1986        ensure!(balance.value >= value, Error::<T>::TokenValueTooLow);19871988        // Send balance to recipient (updates balanceOf of recipient)1989        Self::add_fungible_item(collection_id, recipient, value)?;19901991        // update balanceOf of sender1992        <Balance<T>>::insert(collection_id, (*owner).clone(), balance.value - value);19931994        // Reduce or remove sender1995        if balance.value == value {1996            <FungibleItemList<T>>::remove(collection_id, owner);1997        }1998        else {1999            balance.value -= value;2000            <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), balance);2001        }20022003        Ok(())2004    }20052006    fn transfer_refungible(2007        collection_id: CollectionId,2008        item_id: TokenId,2009        value: u128,2010        owner: T::AccountId,2011        new_owner: T::AccountId,2012    ) -> DispatchResult {2013        Self::token_exists(collection_id, item_id, &owner)?;20142015        let full_item = <ReFungibleItemList<T>>::get(collection_id, item_id);2016        let item = full_item2017            .owner2018            .iter()2019            .filter(|i| i.owner == owner)2020            .next()2021            .ok_or(Error::<T>::NumOverflow)?;2022        let amount = item.fraction;20232024        ensure!(amount >= value, Error::<T>::TokenValueTooLow);20252026        // update balance2027        let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())2028            .checked_sub(value)2029            .ok_or(Error::<T>::NumOverflow)?;2030        <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);20312032        let balancenew_owner = <Balance<T>>::get(collection_id, new_owner.clone())2033            .checked_add(value)2034            .ok_or(Error::<T>::NumOverflow)?;2035        <Balance<T>>::insert(collection_id, new_owner.clone(), balancenew_owner);20362037        let old_owner = item.owner.clone();2038        let new_owner_has_account = full_item.owner.iter().any(|i| i.owner == new_owner);20392040        // transfer2041        if amount == value && !new_owner_has_account {2042            // change owner2043            // new owner do not have account2044            let mut new_full_item = full_item.clone();2045            new_full_item2046                .owner2047                .iter_mut()2048                .find(|i| i.owner == owner)2049                .unwrap()2050                .owner = new_owner.clone();2051            <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);20522053            // update index collection2054            Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;2055        } else {2056            let mut new_full_item = full_item.clone();2057            new_full_item2058                .owner2059                .iter_mut()2060                .find(|i| i.owner == owner)2061                .unwrap()2062                .fraction -= value;20632064            // separate amount2065            if new_owner_has_account {2066                // new owner has account2067                new_full_item2068                    .owner2069                    .iter_mut()2070                    .find(|i| i.owner == new_owner)2071                    .unwrap()2072                    .fraction += value;2073            } else {2074                // new owner do not have account2075                new_full_item.owner.push(Ownership {2076                    owner: new_owner.clone(),2077                    fraction: value,2078                });2079                Self::add_token_index(collection_id, item_id, &new_owner)?;2080            }20812082            <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);2083        }20842085        Ok(())2086    }20872088    fn transfer_nft(2089        collection_id: CollectionId,2090        item_id: TokenId,2091        sender: T::AccountId,2092        new_owner: T::AccountId,2093    ) -> DispatchResult {2094        Self::token_exists(collection_id, item_id, &sender)?;20952096        let mut item = <NftItemList<T>>::get(collection_id, item_id);20972098        ensure!(2099            sender == item.owner,2100            Error::<T>::MustBeTokenOwner2101        );21022103        // update balance2104        let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())2105            .checked_sub(1)2106            .ok_or(Error::<T>::NumOverflow)?;2107        <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);21082109        let balancenew_owner = <Balance<T>>::get(collection_id, new_owner.clone())2110            .checked_add(1)2111            .ok_or(Error::<T>::NumOverflow)?;2112        <Balance<T>>::insert(collection_id, new_owner.clone(), balancenew_owner);21132114        // change owner2115        let old_owner = item.owner.clone();2116        item.owner = new_owner.clone();2117        <NftItemList<T>>::insert(collection_id, item_id, item);21182119        // update index collection2120        Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;21212122        Ok(())2123    }2124    2125    fn set_re_fungible_variable_data(2126        collection_id: CollectionId,2127        item_id: TokenId,2128        data: Vec<u8>2129    ) -> DispatchResult {2130        let mut item = <ReFungibleItemList<T>>::get(collection_id, item_id);21312132        item.variable_data = data;21332134        <ReFungibleItemList<T>>::insert(collection_id, item_id, item);21352136        Ok(())2137    }21382139    fn set_nft_variable_data(2140        collection_id: CollectionId,2141        item_id: TokenId,2142        data: Vec<u8>2143    ) -> DispatchResult {2144        let mut item = <NftItemList<T>>::get(collection_id, item_id);2145        2146        item.variable_data = data;21472148        <NftItemList<T>>::insert(collection_id, item_id, item);2149        2150        Ok(())2151    }21522153    fn init_collection(item: &CollectionType<T::AccountId>) {2154        // check params2155        assert!(2156            item.decimal_points <= MAX_DECIMAL_POINTS,2157            "decimal_points parameter must be lower than MAX_DECIMAL_POINTS"2158        );2159        assert!(2160            item.name.len() <= 64,2161            "Collection name can not be longer than 63 char"2162        );2163        assert!(2164            item.name.len() <= 256,2165            "Collection description can not be longer than 255 char"2166        );2167        assert!(2168            item.token_prefix.len() <= 16,2169            "Token prefix can not be longer than 15 char"2170        );21712172        // Generate next collection ID2173        let next_id = CreatedCollectionCount::get()2174            .checked_add(1)2175            .unwrap();21762177        CreatedCollectionCount::put(next_id);2178    }21792180    fn init_nft_token(collection_id: CollectionId, item: &NftItemType<T::AccountId>) {2181        let current_index = <ItemListIndex>::get(collection_id)2182            .checked_add(1)2183            .unwrap();21842185        let item_owner = item.owner.clone();2186        Self::add_token_index(collection_id, current_index, &item.owner).unwrap();21872188        <ItemListIndex>::insert(collection_id, current_index);21892190        // Update balance2191        let new_balance = <Balance<T>>::get(collection_id, &item_owner)2192            .checked_add(1)2193            .unwrap();2194        <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);2195    }21962197    fn init_fungible_token(collection_id: CollectionId, owner: &T::AccountId, item: &FungibleItemType) {2198        let current_index = <ItemListIndex>::get(collection_id)2199            .checked_add(1)2200            .unwrap();22012202        Self::add_token_index(collection_id, current_index, owner).unwrap();22032204        <ItemListIndex>::insert(collection_id, current_index);22052206        // Update balance2207        let new_balance = <Balance<T>>::get(collection_id, owner)2208            .checked_add(item.value)2209            .unwrap();2210        <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);2211    }22122213    fn init_refungible_token(collection_id: CollectionId, item: &ReFungibleItemType<T::AccountId>) {2214        let current_index = <ItemListIndex>::get(collection_id)2215            .checked_add(1)2216            .unwrap();22172218        let value = item.owner.first().unwrap().fraction;2219        let owner = item.owner.first().unwrap().owner.clone();22202221        Self::add_token_index(collection_id, current_index, &owner).unwrap();22222223        <ItemListIndex>::insert(collection_id, current_index);22242225        // Update balance2226        let new_balance = <Balance<T>>::get(collection_id, &owner)2227            .checked_add(value)2228            .unwrap();2229        <Balance<T>>::insert(collection_id, owner.clone(), new_balance);2230    }22312232    fn add_token_index(collection_id: CollectionId, item_index: TokenId, owner: &T::AccountId) -> DispatchResult {22332234        // add to account limit2235        if <AccountItemCount<T>>::contains_key(owner) {22362237            // bound Owned tokens by a single address2238            let count = <AccountItemCount<T>>::get(owner);2239            ensure!(count < ChainLimit::get().account_token_ownership_limit, Error::<T>::AddressOwnershipLimitExceeded);22402241            <AccountItemCount<T>>::insert(owner.clone(), count2242                .checked_add(1)2243                .ok_or(Error::<T>::NumOverflow)?);2244        }2245        else {2246            <AccountItemCount<T>>::insert(owner.clone(), 1);2247        }22482249        let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner);2250        if list_exists {2251            let mut list = <AddressTokens<T>>::get(collection_id, owner);2252            let item_contains = list.contains(&item_index.clone());22532254            if !item_contains {2255                list.push(item_index.clone());2256            }22572258            <AddressTokens<T>>::insert(collection_id, owner.clone(), list);2259        } else {2260            let mut itm = Vec::new();2261            itm.push(item_index.clone());2262            <AddressTokens<T>>::insert(collection_id, owner.clone(), itm);2263        }22642265        Ok(())2266    }22672268    fn remove_token_index(2269        collection_id: CollectionId,2270        item_index: TokenId,2271        owner: &T::AccountId,2272    ) -> DispatchResult {22732274        // update counter2275        <AccountItemCount<T>>::insert(owner.clone(), 2276            <AccountItemCount<T>>::get(owner)2277            .checked_sub(1)2278            .ok_or(Error::<T>::NumOverflow)?);227922802281        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.retain(|&item| item != item_index);2288                <AddressTokens<T>>::insert(collection_id, owner.clone(), list);2289            }2290        }22912292        Ok(())2293    }22942295    fn move_token_index(2296        collection_id: CollectionId,2297        item_index: TokenId,2298        old_owner: &T::AccountId,2299        new_owner: &T::AccountId,2300    ) -> DispatchResult {2301        Self::remove_token_index(collection_id, item_index, old_owner)?;2302        Self::add_token_index(collection_id, item_index, new_owner)?;23032304        Ok(())2305    }2306    2307    fn ensure_contract_owned(account: T::AccountId, contract: &T::AccountId) -> DispatchResult {2308        if <ContractOwner<T>>::contains_key(contract.clone()) {2309            let owner = <ContractOwner<T>>::get(contract);2310            ensure!(account == owner, Error::<T>::NoPermission);2311        } else {2312            fail!(Error::<T>::NoPermission);2313        }23142315        Ok(())2316    }2317}23182319////////////////////////////////////////////////////////////////////////////////////////////////////2320// Economic models2321// #region23222323/// Fee multiplier.2324pub type Multiplier = FixedU128;23252326type BalanceOf<T> = <<T as transaction_payment::Config>::OnChargeTransaction as transaction_payment::OnChargeTransaction<T>>::Balance;23272328/// Require the transactor pay for themselves and maybe include a tip to gain additional priority2329/// in the queue.2330#[derive(Encode, Decode, Clone, Eq, PartialEq)]2331pub struct ChargeTransactionPayment<T: Config>(#[codec(compact)] BalanceOf<T>);23322333impl<T: Config + Send + Sync> sp_std::fmt::Debug 2334    for ChargeTransactionPayment<T>2335{2336	#[cfg(feature = "std")]2337	fn fmt(&self, f: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {2338		write!(f, "ChargeTransactionPayment<{:?}>", self.0)2339	}2340	#[cfg(not(feature = "std"))]2341	fn fmt(&self, _: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {2342		Ok(())2343	}2344}23452346impl<T: Config> ChargeTransactionPayment<T>2347where2348    T::Call: Dispatchable<Info=DispatchInfo, PostInfo=PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,2349    BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,2350    T::AccountId: AsRef<[u8]>,2351    T::AccountId: UncheckedFrom<T::Hash>,2352{2353    fn traditional_fee(2354        len: usize,2355        info: &DispatchInfoOf<T::Call>,2356        tip: BalanceOf<T>,2357    ) -> BalanceOf<T>2358    where2359        T::Call: Dispatchable<Info = DispatchInfo>,2360    {2361        <transaction_payment::Module<T>>::compute_fee(len as u32, info, tip)2362    }23632364	fn get_priority(len: usize, info: &DispatchInfoOf<T::Call>, final_fee: BalanceOf<T>) -> TransactionPriority {2365        let weight_saturation = T::BlockWeights::get().max_block / info.weight.max(1);2366        let max_block_length = *T::BlockLength::get().max.get(DispatchClass::Normal);2367        let len_saturation = max_block_length as u64 / (len as u64).max(1);2368        let coefficient: BalanceOf<T> = weight_saturation2369            .min(len_saturation)2370            .saturated_into::<BalanceOf<T>>();2371        final_fee2372            .saturating_mul(coefficient)2373            .saturated_into::<TransactionPriority>()2374    }23752376    fn withdraw_fee(2377        &self,2378        who: &T::AccountId,2379        call: &T::Call,2380        info: &DispatchInfoOf<T::Call>,2381        len: usize,2382	) -> Result<2383		(2384			BalanceOf<T>,2385			<<T as transaction_payment::Config>::OnChargeTransaction as transaction_payment::OnChargeTransaction<T>>::LiquidityInfo,2386		),2387		TransactionValidityError,2388	> {2389        let tip = self.0;23902391        // Set fee based on call type. Creating collection costs 1 Unique.2392        // All other transactions have traditional fees so far2393        // let fee = match call.is_sub_type() {2394        //     Some(Call::create_collection(..)) => <BalanceOf<T>>::from(1_000_000_000),2395        //     _ => Self::traditional_fee(len, info, tip), // Flat fee model, use only for testing purposes2396        //                                                 // _ => <BalanceOf<T>>::from(100)2397        // };2398        let fee = Self::traditional_fee(len, info, tip);23992400        // Only mess with balances if fee is not zero.2401        if fee.is_zero() {2402            return <<T as transaction_payment::Config>::OnChargeTransaction as transaction_payment::OnChargeTransaction<T>>::withdraw_fee(who, call, info, fee, tip)2403			.map(|i| (fee, i));2404        }24052406        // Determine who is paying transaction fee based on ecnomic model2407        // Parse call to extract collection ID and access collection sponsor2408        let mut sponsor: T::AccountId = match IsSubType::<Call<T>>::is_sub_type(call) {2409            Some(Call::create_item(collection_id, _owner, _properties)) => {24102411                // sponsor timeout2412                let block_number = <system::Module<T>>::block_number() as T::BlockNumber;24132414                let limit = <Collection<T>>::get(collection_id).limits.sponsor_transfer_timeout;2415                let mut sponsored = true;2416                if <CreateItemBasket<T>>::contains_key((collection_id, &who)) {2417                    let last_tx_block = <CreateItemBasket<T>>::get((collection_id, &who));2418                    let limit_time = last_tx_block + limit.into();2419                    if block_number <= limit_time {2420                        sponsored = false;2421                    }2422                }2423                if sponsored {2424                    <CreateItemBasket<T>>::insert((collection_id, who.clone()), block_number);2425                }24262427                // check free create limit2428                if (<Collection<T>>::get(collection_id).limits.sponsored_data_size >= (_properties.len() as u32)) &&2429                   (<Collection<T>>::get(collection_id).sponsor_confirmed) &&2430                   (sponsored)2431                {2432                    <Collection<T>>::get(collection_id).sponsor2433                } else {2434                    T::AccountId::default()2435                }2436            }2437            Some(Call::transfer(_new_owner, collection_id, item_id, _value)) => {2438                2439                let mut sponsor_transfer = false;2440                if <Collection<T>>::get(collection_id).sponsor_confirmed {24412442                    let collection_limits = <Collection<T>>::get(collection_id).limits;2443                    let collection_mode = <Collection<T>>::get(collection_id).mode;2444    2445                    // sponsor timeout2446                    let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2447                    sponsor_transfer = match collection_mode {2448                        CollectionMode::NFT => {2449    2450                            // get correct limit2451                            let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2452                                collection_limits.sponsor_transfer_timeout2453                            } else {2454                                ChainLimit::get().nft_sponsor_transfer_timeout2455                            };2456    2457                            let mut sponsored = true;2458                            if <NftTransferBasket<T>>::contains_key(collection_id, item_id) {2459                                let last_tx_block = <NftTransferBasket<T>>::get(collection_id, item_id);2460                                let limit_time = last_tx_block + limit.into();2461                                if block_number <= limit_time {2462                                    sponsored = false;2463                                }2464                            }2465                            if sponsored {2466                                <NftTransferBasket<T>>::insert(collection_id, item_id, block_number);2467                            }24682469                            sponsored2470                        }2471                        CollectionMode::Fungible(_) => {2472    2473                            // get correct limit2474                            let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2475                                collection_limits.sponsor_transfer_timeout2476                            } else {2477                                ChainLimit::get().fungible_sponsor_transfer_timeout2478                            };2479    2480                            let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2481                            let mut sponsored = true;2482                            if <FungibleTransferBasket<T>>::contains_key(collection_id, who) {2483                                let last_tx_block = <FungibleTransferBasket<T>>::get(collection_id, who);2484                                let limit_time = last_tx_block + limit.into();2485                                if block_number <= limit_time {2486                                    sponsored = false;2487                                }2488                            }2489                            if sponsored {2490                                <FungibleTransferBasket<T>>::insert(collection_id, who, block_number);2491                            }24922493                            sponsored2494                        }2495                        CollectionMode::ReFungible => {2496    2497                            // get correct limit2498                            let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2499                                collection_limits.sponsor_transfer_timeout2500                            } else {2501                                ChainLimit::get().refungible_sponsor_transfer_timeout2502                            };2503    2504                            let mut sponsored = true;2505                            if <ReFungibleTransferBasket<T>>::contains_key(collection_id, item_id) {2506                                let last_tx_block = <ReFungibleTransferBasket<T>>::get(collection_id, item_id);2507                                let limit_time = last_tx_block + limit.into();2508                                if block_number <= limit_time {2509                                    sponsored = false;2510                                }2511                            }2512                            if sponsored {2513                                <ReFungibleTransferBasket<T>>::insert(collection_id, item_id, block_number);2514                            }25152516                            sponsored2517                        }2518                        _ => {2519                            false2520                        },2521                    };2522                }25232524                if !sponsor_transfer {2525                    T::AccountId::default()2526                } else {2527                    <Collection<T>>::get(collection_id).sponsor2528                }2529            }25302531            _ => T::AccountId::default(),2532        };25332534        // Sponsor smart contracts2535        sponsor = match IsSubType::<pallet_contracts::Call<T>>::is_sub_type(call) {25362537            // On instantiation: set the contract owner2538            Some(pallet_contracts::Call::instantiate(_endowment, _gas_limit, code_hash, _data, salt)) => {25392540                let new_contract_address = <pallet_contracts::Module<T>>::contract_address(2541                    &who,2542                    code_hash,2543                    salt,2544                );2545                <ContractOwner<T>>::insert(new_contract_address.clone(), who.clone());25462547                T::AccountId::default()2548            },25492550            // When the contract is called, check if the sponsoring is enabled and pay fees from contract endowment if it is2551            Some(pallet_contracts::Call::call(dest, _value, _gas_limit, _data)) => {25522553                let called_contract: T::AccountId = T::Lookup::lookup((*dest).clone()).unwrap_or(T::AccountId::default());25542555                let owned_contract = <ContractOwner<T>>::contains_key(called_contract.clone())2556                  && <ContractOwner<T>>::get(called_contract.clone()) == *who;2557                let white_list_enabled = <ContractWhiteListEnabled<T>>::contains_key(called_contract.clone()) && <ContractWhiteListEnabled<T>>::get(called_contract.clone());2558                  2559                if !owned_contract && white_list_enabled {2560                    if !<ContractWhiteList<T>>::contains_key(called_contract.clone(), who) {2561                        return Err(InvalidTransaction::Call.into());2562                    }2563                }25642565                let mut sponsor_transfer = false;2566                if <ContractSponsoringRateLimit<T>>::contains_key(called_contract.clone()) {2567                    let last_tx_block = <ContractSponsorBasket<T>>::get((&called_contract, &who));2568                    let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2569                    let rate_limit = <ContractSponsoringRateLimit<T>>::get(&called_contract);2570                    let limit_time = last_tx_block + rate_limit;25712572                    if block_number >= limit_time {2573                        <ContractSponsorBasket<T>>::insert((called_contract.clone(), who.clone()), block_number);2574                        sponsor_transfer = true;2575                    }2576                } else {2577                    sponsor_transfer = false;2578                }2579               2580                2581                let mut sp = T::AccountId::default();2582                if sponsor_transfer {2583                    if <ContractSelfSponsoring<T>>::contains_key(called_contract.clone()) {2584                        if <ContractSelfSponsoring<T>>::get(called_contract.clone()) {2585                            sp = called_contract;2586                        }2587                    }2588                }25892590                sp2591            },25922593            _ => sponsor,2594        };25952596        let mut who_pays_fee: T::AccountId = sponsor.clone();2597        if sponsor == T::AccountId::default() {2598            who_pays_fee = who.clone();2599        }26002601		<<T as transaction_payment::Config>::OnChargeTransaction as transaction_payment::OnChargeTransaction<T>>::withdraw_fee(&who_pays_fee, call, info, fee, tip)2602			.map(|i| (fee, i))2603    }2604}260526062607impl<T: Config + Send + Sync> SignedExtension2608    for ChargeTransactionPayment<T>2609where2610    BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,2611    T::Call: Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,2612    T::AccountId: AsRef<[u8]>,2613    T::AccountId: UncheckedFrom<T::Hash>,2614{2615    const IDENTIFIER: &'static str = "ChargeTransactionPayment";2616    type AccountId = T::AccountId;2617    type Call = T::Call;2618    type AdditionalSigned = ();2619    type Pre = (2620        // tip2621        BalanceOf<T>,2622        // who pays fee2623        Self::AccountId,2624		// imbalance resulting from withdrawing the fee2625		<<T as transaction_payment::Config>::OnChargeTransaction as transaction_payment::OnChargeTransaction<T>>::LiquidityInfo,2626    );2627    fn additional_signed(&self) -> sp_std::result::Result<(), TransactionValidityError> {2628        Ok(())2629    }26302631    fn validate(2632        &self,2633        who: &Self::AccountId,2634        call: &Self::Call,2635        info: &DispatchInfoOf<Self::Call>,2636        len: usize,2637    ) -> TransactionValidity {2638		let (fee, _) = self.withdraw_fee(who, call, info, len)?;2639		Ok(ValidTransaction {2640			priority: Self::get_priority(len, info, fee),2641			..Default::default()2642		})2643    }26442645    fn pre_dispatch(2646        self,2647        who: &Self::AccountId,2648        call: &Self::Call,2649        info: &DispatchInfoOf<Self::Call>,2650        len: usize,2651    ) -> Result<Self::Pre, TransactionValidityError> {2652        let (_fee, imbalance) = self.withdraw_fee(who, call, info, len)?;2653        Ok((self.0, who.clone(), imbalance))2654    }26552656    fn post_dispatch(2657        pre: Self::Pre,2658        info: &DispatchInfoOf<Self::Call>,2659        post_info: &PostDispatchInfoOf<Self::Call>,2660        len: usize,2661        _result: &DispatchResult,2662    ) -> Result<(), TransactionValidityError> {2663		let (tip, who, imbalance) = pre;2664		let actual_fee = transaction_payment::Module::<T>::compute_actual_fee(2665			len as u32,2666			info,2667			post_info,2668			tip,2669		);2670		<T as transaction_payment::Config>::OnChargeTransaction::correct_and_deposit_fee(&who, info, post_info, actual_fee, tip, imbalance)?;2671		Ok(())2672    }2673}26742675// #endregion